/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using ForwardWindow7Stride4 = WindowStrideTest<Pair, 7, 4>;
TYPED_TEST_SUITE(ForwardWindow7Stride4, GTestTypeTriples);
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {24525., 36890., 27925., 63630., 90013.,
                                         64610., 47125., 64750., 45125.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60613., 65513., 114513., 119413.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48425.,  49050.,  72800.,  73780.,  55075.,  55850.,
      125230., 127260., 177037., 180026., 126980., 129220.,
      91975.,  94250.,  126210., 129500., 87825.,  90250.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {119413., 121226., 129017., 131026.,
                                         225057., 229026., 234661., 238826.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      96225.,  96850.,  97475.,  98100.,  144620., 145600., 146580., 147560.,
      109375., 110150., 110925., 111700., 248430., 250460., 252490., 254520.,
      351085., 354074., 357063., 360052., 251720., 253960., 256200., 258440.,
      181675., 183950., 186225., 188500., 249130., 252420., 255710., 259000.,
      173225., 175650., 178075., 180500.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237013., 238826., 240639., 242452., 256025., 258034., 260043., 262052.,
      446145., 450114., 454083., 458052., 465157., 469322., 473487., 477652.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {193325., 290955., 220325.,
                                         503195., 711725., 510755.,
                                         371525., 510195., 355325.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {478877., 517685., 905765., 944573.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      384175., 386650.,  578025.,  581910.,  437575.,  440650.,
      998305., 1006390., 1411543., 1423450., 1012585., 1021510.,
      733975., 743050.,  1007265., 1020390., 700975.,  710650.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {950551.,  957754.,  1027383.,
                                         1035370., 1795703., 1811530.,
                                         1872535., 1889146.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      765875.,  768350.,  770825.,  773300.,  1152165., 1156050.,
      1159935., 1163820., 872075.,  875150.,  878225.,  881300.,
      1988525., 1996610., 2004695., 2012780., 2811179., 2823086.,
      2834993., 2846900., 2016245., 2025170., 2034095., 2043020.,
      1458875., 1467950., 1477025., 1486100., 2001405., 2014530.,
      2027655., 2040780., 1392275., 1401950., 1411625., 1421300.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1893899., 1901102., 1908305., 1915508., 2046779., 2054766.,
      2062753., 2070740., 3575579., 3591406., 3607233., 3623060.,
      3728459., 3745070., 3761681., 3778292.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1535150., 2311050., 1750350.,
                                         4002250., 5660382., 4061610.,
                                         2950350., 4050410., 2819950.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3807006., 4115902., 7204862.,
                                         7513758.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3060450., 3070300., 4606630.,  4622100.,  3488450., 3500700.,
      7972230., 8004500., 11273234., 11320764., 8087590., 8123220.,
      5864450., 5900700., 8048390.,  8100820.,  5601250., 5639900.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7585298.,  7614012.,  8199954.,
                                         8231804.,  14346514., 14409724.,
                                         14961170., 15027516.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2112330.,  2122180.,  2132030.,  2141880.,  3409118.,  3424588.,
      3440058.,  3455528.,  2836906.,  2849156.,  2861406.,  2873656.,
      7227646.,  7259916.,  7292186.,  7324456.,  10582650., 10630180.,
      10677710., 10725240., 8046878.,  8082508.,  8118138.,  8153768.,
      8900202.,  8936452.,  8972702.,  9008952.,  13153598., 13206028.,
      13258458., 13310888., 10175690., 10214340., 10252990., 10291640.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6567930.,  6596644.,  6625358.,  6654072.,  7237050.,  7268900.,
      7300750.,  7332600.,  13928250., 13991460., 14054670., 14117880.,
      14597370., 14663716., 14730062., 14796408.};
  const std::array<int, 4> in_shape = {{1, 11, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31940., 40740., 30600., 82243., 98735.,
                                         70630., 60350., 70910., 49300.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65660., 70560., 124460., 129360.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63055.,  63880.,  80395.,  81480.,  60350.,  61200.,
      161819., 164486., 194187., 197470., 138810., 141260.,
      117715., 120700., 138215., 141820., 95950.,  98600.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {129360., 131320., 138964., 141120.,
                                         244608., 248920., 254212., 258720.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      125285., 126110., 126935., 127760., 159705., 160790., 161875., 162960.,
      119850., 120700., 121550., 122400., 320971., 323638., 326305., 328972.,
      385091., 388374., 391657., 394940., 275170., 277620., 280070., 282520.,
      232445., 235430., 238415., 241400., 272825., 276430., 280035., 283640.,
      189250., 191900., 194550., 197200.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      256760., 258720., 260680., 262640., 275772., 277928., 280084., 282240.,
      484904., 489216., 493528., 497840., 503916., 508424., 512932., 517440.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {251950., 321545., 241575.,
                                         650510., 780913., 558495.,
                                         475750., 558845., 388275.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {518959., 557767., 984655., 1023463.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      500630.,  503900.,  638785.,  643090.,  479775.,  483150.,
      1290394., 1301020., 1548743., 1561826., 1107225., 1116990.,
      939590.,  951500.,  1103305., 1117690., 765975.,  776550.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1030127., 1037918., 1106959.,
                                         1115534., 1952111., 1969310.,
                                         2028943., 2046926.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      997990.,  1001260., 1004530., 1007800., 1273265., 1277570.,
      1281875., 1286180., 956175.,  959550.,  962925.,  966300.,
      2570162., 2580788., 2591414., 2602040., 3084403., 3097486.,
      3110569., 3123652., 2204685., 2214450., 2224215., 2233980.,
      1867270., 1879180., 1891090., 1903000., 2192225., 2206610.,
      2220995., 2235380., 1521375., 1531950., 1542525., 1553100.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2052463., 2060254., 2068045., 2075836., 2205343., 2213918.,
      2222493., 2231068., 3887023., 3904222., 3921421., 3938620.,
      4039903., 4057886., 4075869., 4093852.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2001380., 2554930., 1919750.,
                                         5174428., 6211534., 4441850.,
                                         3777860., 4437090., 3081750.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4126486., 4435382., 7833238.,
                                         8142134.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3989740.,  4002760.,  5092710.,  5109860.,  3826050., 3839500.,
      10306436., 10348856., 12370834., 12423068., 8844710., 8883700.,
      7508140.,  7555720.,  8816710.,  8874180.,  6121250., 6163500.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8221906.,  8252972.,  8836562.,
                                         8870764.,  15597778., 15666476.,
                                         16212434., 16284268.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2827004.,  2840024.,  2853044.,  2866064.,  3789774.,  3806924.,
      3824074.,  3841224.,  3117690.,  3131140.,  3144590.,  3158040.,
      9532756.,  9575176.,  9617596.,  9660016.,  11626266., 11678500.,
      11730734., 11782968., 8804094.,  8843084.,  8882074.,  8921064.,
      11905916., 11953496., 12001076., 12048656., 14287886., 14341260.,
      14394634., 14448008., 8115514.,  8149572.,  8183630.,  8217688.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7109706.,  7140772.,  7171838.,  7202904.,  7778826.,  7813028.,
      7847230.,  7881432.,  15139146., 15207844., 15276542., 15345240.,
      14290698., 14356388., 14422078., 14487768.};
  const std::array<int, 4> in_shape = {{1, 11, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30525., 45080.,  49560.,  28650.,
                                         80220., 112504., 117404., 65296.,
                                         59575., 81340.,  83860.,  45030.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {75754., 80654., 144354., 149254.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60275.,  61050.,  88970.,  90160.,  97790.,  99120.,  56490.,  57300.,
      157885., 160440., 221284., 225008., 230888., 234808., 128282., 130592.,
      116275., 119150., 158550., 162680., 163450., 167720., 87570.,  90060.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {149254., 151508., 158858., 161308.,
                                         283710., 288708., 293314., 298508.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119775., 120550., 121325., 122100., 176750., 177940., 179130., 180320.,
      194250., 195580., 196910., 198240., 112170., 112980., 113790., 114600.,
      313215., 315770., 318325., 320880., 438844., 442568., 446292., 450016.,
      457856., 461776., 465696., 469616., 254254., 256564., 258874., 261184.,
      229675., 232550., 235425., 238300., 312970., 317100., 321230., 325360.,
      322630., 326900., 331170., 335440., 172650., 175140., 177630., 180120.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296254., 298508., 300762., 303016., 315266., 317716., 320166., 322616.,
      562422., 567420., 572418., 577416., 581434., 586628., 591822., 597016.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {241025., 356055., 391615., 226380.,
                                         634865., 890183., 928991., 516460.,
                                         469925., 641235., 661115., 354620.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {599123., 637931., 1142435., 1181243.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      478975.,  482050.,  707385.,  712110.,  777945.,  783230.,
      449540.,  452760.,  1259545., 1269730., 1765519., 1780366.,
      1842351., 1857982., 1023708., 1032920., 928375.,  939850.,
      1265985., 1282470., 1305185., 1322230., 699300.,  709240.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1189279., 1198246., 1266111.,
                                         1275862., 2264927., 2284870.,
                                         2341759., 2362486.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      954875.,  957950.,  961025.,  964100.,  1410045., 1414770., 1419495.,
      1424220., 1550605., 1555890., 1561175., 1566460., 895860.,  899080.,
      902300.,  905520.,  2508905., 2519090., 2529275., 2539460., 3516191.,
      3531038., 3545885., 3560732., 3669071., 3684702., 3700333., 3715964.,
      2038204., 2047416., 2056628., 2065840., 1845275., 1856750., 1868225.,
      1879700., 2515485., 2531970., 2548455., 2564940., 2593325., 2610370.,
      2627415., 2644460., 1388660., 1398600., 1408540., 1418480.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2369591., 2378558., 2387525., 2396492., 2522471., 2532222.,
      2541973., 2551724., 4509911., 4529854., 4549797., 4569740.,
      4662791., 4683518., 4704245., 4724972.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1915550., 2830170., 3113530., 1799800., 5051410., 7082166.,
      7391062., 4108104., 3732750., 5092010., 5249930., 2814520.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4765446., 5074342., 9089990.,
                                         9398886.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3818850.,  3831100.,  5641510.,  5660340.,  6205990.,  6227060.,
      3586760.,  3599600.,  10062150., 10102820., 14105042., 14164332.,
      14719698., 14782124., 8179416.,  8216208.,  7419650.,  7465500.,
      10118150., 10184020., 10431750., 10499860., 5589320.,  5629040.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9495122.,  9530892., 10109778.,
                                         10148684., 9646162., 9701260.,
                                         9081170.,  9135308.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x11x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2619114.,  2631364.,  2643614.,  2655864.,  4123838.,  4142668.,
      4161498.,  4180328.,  4693502.,  4714572.,  4735642.,  4756712.,
      3154792.,  3167632.,  3180472.,  3193312.,  9113518.,  9154188.,
      9194858.,  9235528.,  13211658., 13270948., 13330238., 13389528.,
      13880778., 13943204., 14005630., 14068056., 8646136.,  8682928.,
      8719720.,  8756512.,  6495978.,  6525444.,  6554910.,  6584376.,
      6871742.,  6908940.,  6946138.,  6983336.,  7398398.,  7437836.,
      7477274.,  7516712.,  4208488.,  4231824.,  4255160.,  4278496.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x11x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8193258.,  8229028.,  8264798.,  8300568.,  8862378.,  8901284.,
      8940190.,  8979096.,  13260138., 13315236., 13370334., 13425432.,
      13671210., 13725348., 13779486., 13833624.};
  const std::array<int, 4> in_shape = {{1, 11, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33790., 49700., 36910., 73640., 103488., 73850., 52350., 71680., 49800.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60613., 65513., 114513., 119413.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      66665.,  67580.,  97993.,  99400.,  72725.,  73820.,
      144865., 147280., 203448., 206976., 145075., 147700.,
      102150., 104700., 139685., 143360., 96900.,  99600.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {119413., 121226., 129017., 131026.,
                                         225057., 229026., 234661., 238826.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      132415., 133330., 134245., 135160., 194579., 195986., 197393., 198800.,
      144355., 145450., 146545., 147640., 287315., 289730., 292145., 294560.,
      403368., 406896., 410424., 413952., 287525., 290150., 292775., 295400.,
      201750., 204300., 206850., 209400., 275695., 279370., 283045., 286720.,
      191100., 193800., 196500., 199200.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237013., 238826., 240639., 242452., 256025., 258034., 260043., 262052.,
      446145., 450114., 454083., 458052., 465157., 469322., 473487., 477652.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {266750., 392434., 291470.,
                                         582505., 818447., 583905.,
                                         412775., 564865., 392175.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {478877., 517685., 905765., 944573.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      529870.,  533500.,  779282.,  784868.,  578590.,  582940.,
      1155385., 1165010., 1622831., 1636894., 1157345., 1167810.,
      815375.,  825550.,  1115065., 1129730., 773575.,  784350.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {950551.,  957754.,  1027383.,
                                         1035370., 1795703., 1811530.,
                                         1872535., 1889146.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1056110., 1059740., 1063370., 1067000., 1552978., 1558564.,
      1564150., 1569736., 1152830., 1157180., 1161530., 1165880.,
      2301145., 2310770., 2320395., 2330020., 3231599., 3245662.,
      3259725., 3273788., 2304225., 2314690., 2325155., 2335620.,
      1620575., 1630750., 1640925., 1651100., 2215465., 2230130.,
      2244795., 2259460., 1536375., 1547150., 1557925., 1568700.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1893899., 1901102., 1908305., 1915508., 2046779., 2054766.,
      2062753., 2070740., 3575579., 3591406., 3607233., 3623060.,
      3728459., 3745070., 3761681., 3778292.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2119780., 3118892., 2316580.,
                                         4633650., 6509846., 4643730.,
                                         3278150., 4484690., 3112550.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3807006., 4115902., 7204862.,
                                         7513758.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4225100., 4239560., 6215524.,  6237784.,  4615820., 4633160.,
      9228870., 9267300., 12963538., 13019692., 9245670., 9287460.,
      6515650., 6556300., 8910790.,  8969380.,  6182050., 6225100.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7585298.,  7614012.,  8199954.,
                                         8231804.,  14346514., 14409724.,
                                         14961170., 15027516.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3265564.,  3280024.,  3294484.,  3308944.,  5088212.,  5110472.,
      5132732.,  5154992.,  4095324.,  4112664.,  4130004.,  4147344.,
      8563310.,  8601740.,  8640170.,  8678600.,  12422730., 12478884.,
      12535038., 12591192., 9365646.,  9407436.,  9449226.,  9491016.,
      9927866.,  9968516.,  10009166., 10049816., 14474926., 14529420.,
      14583914., 14638408., 8236314.,  8271172.,  8306030.,  8340888.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6567930.,  6596644.,  6625358.,  6654072.,  7237050.,  7268900.,
      7300750.,  7332600.,  13928250., 13991460., 14054670., 14117880.,
      14597370., 14663716., 14730062., 14796408.};
  const std::array<int, 4> in_shape = {{1, 12, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      43899., 54747., 40410., 95095., 113435., 80710., 67010., 78470., 54400.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65660., 70560., 124460., 129360.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86592.,  87798.,  107940., 109494., 79620.,  80820.,
      187019., 190190., 222999., 226870., 158550., 161420.,
      130675., 134020., 152915., 156940., 105850., 108800.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {129360., 131320., 138964., 141120.,
                                         244608., 248920., 254212., 258720.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      171978., 173184., 174390., 175596., 214326., 215880., 217434., 218988.,
      158040., 159240., 160440., 161640., 370867., 374038., 377209., 380380.,
      442127., 445998., 449869., 453740., 314230., 317100., 319970., 322840.,
      258005., 261350., 264695., 268040., 301805., 305830., 309855., 313880.,
      208750., 211700., 214650., 217600.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      256760., 258720., 260680., 262640., 275772., 277928., 280084., 282240.,
      484904., 489216., 493528., 497840., 503916., 508424., 512932., 517440.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {346728., 432516., 319260.,
                                         752318., 897337., 638295.,
                                         528310., 618485., 428475.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {518959., 557767., 984655., 1023463.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      688668.,  693456.,  858858.,  865032.,  633750.,  638520.,
      1491994., 1504636., 1779239., 1794674., 1265145., 1276590.,
      1043270., 1056620., 1220905., 1236970., 845175.,  856950.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1030127., 1037918., 1106959.,
                                         1115534., 1952111., 1969310.,
                                         2028943., 2046926.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1372548., 1377336., 1382124., 1386912., 1711542., 1717716.,
      1723890., 1730064., 1262730., 1267500., 1272270., 1277040.,
      2971346., 2983988., 2996630., 3009272., 3543043., 3558478.,
      3573913., 3589348., 2518845., 2530290., 2541735., 2553180.,
      2073190., 2086540., 2099890., 2113240., 2425745., 2441810.,
      2457875., 2473940., 1678575., 1690350., 1702125., 1713900.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2052463., 2060254., 2068045., 2075836., 2205343., 2213918.,
      2222493., 2231068., 3887023., 3904222., 3921421., 3938620.,
      4039903., 4057886., 4075869., 4093852.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2756040., 3438372., 2538060.,
                                         5984860., 7138222., 5076890.,
                                         4195460., 4910850., 3400950.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4126486., 4435382., 7833238.,
                                         8142134.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5493000.,  5512080.,  6852132.,  6876744.,  5057100.,  5076120.,
      11919236., 11969720., 14214802., 14276444., 10108070., 10153780.,
      8337580.,  8390920.,  9757510.,  9821700.,  6754850.,  6801900.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8221906.,  8252972.,  8836562.,
                                         8870764.,  15597778., 15666476.,
                                         16212434., 16284268.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4352904.,  4371984.,  4391064.,  4410144.,  5629988.,  5654600.,
      5679212.,  5703824.,  4492876.,  4511896.,  4530916.,  4549936.,
      11275732., 11326216., 11376700., 11427184., 13633626., 13695268.,
      13756910., 13818552., 10242750., 10288460., 10334170., 10379880.,
      10130684., 10171736., 10212788., 10253840., 10164174., 10209932.,
      10255690., 10301448., 5210234.,  5238852.,  5267470.,  5296088.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7109706.,  7140772.,  7171838.,  7202904.,  7778826.,  7813028.,
      7847230.,  7881432.,  15139146., 15207844., 15276542., 15345240.,
      14290698., 14356388., 14422078., 14487768.};
  const std::array<int, 4> in_shape = {{1, 12, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {42265., 61250.,  66038.,  37670.,
                                         92960., 129654., 134554., 74508.,
                                         66225., 90160.,  92680.,  49650.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {75754., 80654., 144354., 149254.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83390.,  84530.,  120778., 122500., 130186., 132076., 74200.,  75340.,
      182875., 185920., 254898., 259308., 264502., 269108., 146314., 149016.,
      129225., 132450., 175700., 180320., 180600., 185360., 96530.,  99300.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {149254., 151508., 158858., 161308.,
                                         283710., 288708., 293314., 298508.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      165640., 166780., 167920., 169060., 239834., 241556., 243278., 245000.,
      258482., 260372., 262262., 264152., 147260., 148400., 149540., 150680.,
      362705., 365750., 368795., 371840., 505386., 509796., 514206., 518616.,
      524398., 529004., 533610., 538216., 289926., 292628., 295330., 298032.,
      255225., 258450., 261675., 264900., 346780., 351400., 356020., 360640.,
      356440., 361200., 365960., 370720., 190290., 193060., 195830., 198600.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296254., 298508., 300762., 303016., 315266., 317716., 320166., 322616.,
      562422., 567420., 572418., 577416., 581434., 586628., 591822., 597016.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {334100., 484204.,  522172.,  297808.,
                                         735805., 1026011., 1064819., 589372.,
                                         522425., 710815.,  730695.,  391020.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {599123., 637931., 1142435., 1181243.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      663670.,  668200.,  961562.,  968408.,  1036826., 1044344.,
      591080.,  595616.,  1459465., 1471610., 2034431., 2052022.,
      2111263., 2129638., 1167964., 1178744., 1031975., 1044850.,
      1403185., 1421630., 1442385., 1461390., 770980.,  782040.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1189279., 1198246., 1266111.,
                                         1275862., 2264927., 2284870.,
                                         2341759., 2362486.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1322810., 1327340., 1331870., 1336400., 1916278., 1923124., 1929970.,
      1936816., 2066134., 2073652., 2081170., 2088688., 1177624., 1182160.,
      1186696., 1191232., 2906785., 2918930., 2931075., 2943220., 4051271.,
      4068862., 4086453., 4104044., 4204151., 4222526., 4240901., 4259276.,
      2325148., 2335928., 2346708., 2357488., 2051075., 2063950., 2076825.,
      2089700., 2787925., 2806370., 2824815., 2843260., 2865765., 2884770.,
      2903775., 2922780., 1530900., 1541960., 1553020., 1564080.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2369591., 2378558., 2387525., 2396492., 2522471., 2532222.,
      2541973., 2551724., 4509911., 4529854., 4549797., 4569740.,
      4662791., 4683518., 4704245., 4724972.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2656780., 3850532., 4152932., 2368304., 5855010., 8163302.,
      8472198., 4688264., 4149950., 5644730., 5802650., 3103480.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4765446., 5074342., 9089990.,
                                         9398886.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5295500.,  5313560.,  7673764., 7701064., 8275876.,  8305864.,
      4718512.,  4736608.,  9326790., 9369156., 11038034., 11093964.,
      11652690., 11711756., 6449880., 6484752., 2538626.,  2563452.,
      2786182.,  2816884.,  3099782., 3132724., 1640776.,  1660400.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9495122.,  9530892., 10109778.,
                                         10148684., 9646162., 9701260.,
                                         9081170.,  9135308.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x12x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4075660.,  4093720.,  4111780.,  4129840.,  6230180.,  6257480.,
      6284780.,  6312080.,  6874660.,  6904648.,  6934636.,  6964624.,
      4495536.,  4513632.,  4531728.,  4549824.,  9295886.,  9338252.,
      9380618.,  9422984.,  12471338., 12527268., 12583198., 12639128.,
      13140458., 13199524., 13258590., 13317656., 8465784.,  8500656.,
      8535528.,  8570400.,  4324362.,  4349188.,  4374014.,  4398840.,
      4715294.,  4745996.,  4776698.,  4807400.,  5241950.,  5274892.,
      5307834.,  5340776.,  3261928.,  3281552.,  3301176.,  3320800.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x12x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8193258.,  8229028.,  8264798.,  8300568.,  8862378.,  8901284.,
      8940190.,  8979096.,  13260138., 13315236., 13370334., 13425432.,
      13671210., 13725348., 13779486., 13833624.};
  const std::array<int, 4> in_shape = {{1, 12, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {24525.,  36890., 27925.,  63630.,
                                         90013.,  64610., 103670., 143913.,
                                         101570., 42110., 56602.,  38550.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60613., 65513., 114513., 119413.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48425.,  49050.,  72800.,  73780.,  55075.,  55850.,  125230., 127260.,
      177037., 180026., 126980., 129220., 203770., 207340., 282681., 287826.,
      199360., 203140., 81630.,  84220.,  109494., 113204., 74390.,  77100.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {119413., 121226., 129017., 131026.,
                                         225057., 229026., 234661., 238826.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      96225.,  96850.,  97475.,  98100.,  144620., 145600., 146580., 147560.,
      109375., 110150., 110925., 111700., 248430., 250460., 252490., 254520.,
      351085., 354074., 357063., 360052., 251720., 253960., 256200., 258440.,
      403970., 407540., 411110., 414680., 560217., 565362., 570507., 575652.,
      394940., 398720., 402500., 406280., 160670., 163260., 165850., 168440.,
      215278., 218988., 222698., 226408., 146070., 148780., 151490., 154200.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237013., 238826., 240639., 242452., 256025., 258034., 260043., 262052.,
      446145., 450114., 454083., 458052., 465157., 469322., 473487., 477652.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {193325., 290955., 220325., 503195.,
                                         711725., 510755., 820435., 1138613.,
                                         803355., 331100., 444612., 302460.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {478877., 517685., 905765., 944573.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      384175.,  386650.,  578025.,  581910.,  437575.,  440650.,
      998305.,  1006390., 1411543., 1423450., 1012585., 1021510.,
      1626625., 1640870., 2256695., 2277226., 1591625., 1606710.,
      651860.,  662200.,  874412.,  889224.,  594100.,  604920.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {950551.,  957754.,  1027383.,
                                         1035370., 1795703., 1811530.,
                                         1872535., 1889146.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      765875.,  768350.,  770825.,  773300.,  1152165., 1156050., 1159935.,
      1163820., 872075.,  875150.,  878225.,  881300.,  1988525., 1996610.,
      2004695., 2012780., 2811179., 2823086., 2834993., 2846900., 2016245.,
      2025170., 2034095., 2043020., 3239005., 3253250., 3267495., 3281740.,
      4492859., 4513390., 4533921., 4554452., 3168165., 3183250., 3198335.,
      3213420., 1293380., 1303720., 1314060., 1324400., 1734012., 1748824.,
      1763636., 1778448., 1177380., 1188200., 1199020., 1209840.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1893899., 1901102., 1908305., 1915508., 2046779., 2054766.,
      2062753., 2070740., 3575579., 3591406., 3607233., 3623060.,
      3728459., 3745070., 3761681., 3778292.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1535150., 2311050., 1750350., 4002250., 5660382., 4061610.,
      6527850., 9058238., 6390090., 2625720., 3524136., 2395960.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {3807006., 4115902., 7204862.,
                                         7513758.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3060450., 3070300., 4606630.,  4622100.,  3488450., 3500700.,
      7972230., 8004500., 11273234., 11320764., 8087590., 8123220.,
      9189510., 9236180., 11472658., 11536252., 6584102., 6625940.,
      1605640., 1626480., 1746200.,  1772624.,  816520.,  831088.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7585298.,  7614012.,  8199954.,
                                         8231804.,  14346514., 14409724.,
                                         14961170., 15027516.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2112330.,  2122180.,  2132030.,  2141880.,  3409118.,  3424588.,
      3440058.,  3455528.,  2836906.,  2849156.,  2861406.,  2873656.,
      7227646.,  7259916.,  7292186.,  7324456.,  10582650., 10630180.,
      10677710., 10725240., 8046878.,  8082508.,  8118138.,  8153768.,
      10204862., 10251532., 10298202., 10344872., 14275002., 14338596.,
      14402190., 14465784., 10505950., 10547788., 10589626., 10631464.,
      3190440.,  3211280.,  3232120.,  3252960.,  3465976.,  3492400.,
      3518824.,  3545248.,  1618472.,  1633040.,  1647608.,  1662176.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6567930.,  6596644.,  6625358.,  6654072.,  7237050.,  7268900.,
      7300750.,  7332600.,  13928250., 13991460., 14054670., 14117880.,
      14597370., 14663716., 14730062., 14796408.};
  const std::array<int, 4> in_shape = {{1, 14, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31940.,  40740., 30600.,  82243.,
                                         98735.,  70630., 133651., 157535.,
                                         110950., 53530., 61922.,  42100.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65660., 70560., 124460., 129360.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63055.,  63880.,  80395.,  81480.,  60350.,  61200.,  161819., 164486.,
      194187., 197470., 138810., 141260., 262619., 267302., 309435., 315070.,
      217770., 221900., 103664., 107060., 119784., 123844., 81240.,  84200.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {129360., 131320., 138964., 141120.,
                                         244608., 248920., 254212., 258720.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      125285., 126110., 126935., 127760., 159705., 160790., 161875., 162960.,
      119850., 120700., 121550., 122400., 320971., 323638., 326305., 328972.,
      385091., 388374., 391657., 394940., 275170., 277620., 280070., 282520.,
      520555., 525238., 529921., 534604., 613235., 618870., 624505., 630140.,
      431410., 435540., 439670., 443800., 203932., 207328., 210724., 214120.,
      235508., 239568., 243628., 247688., 159520., 162480., 165440., 168400.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      256760., 258720., 260680., 262640., 275772., 277928., 280084., 282240.,
      484904., 489216., 493528., 497840., 503916., 508424., 512932., 517440.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {251950., 321545., 241575.,  650510.,
                                         780913., 558495., 1057742., 1246609.,
                                         877695., 420752., 486472.,  330360.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {518959., 557767., 984655., 1023463.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      500630.,  503900.,  638785.,  643090.,  479775.,  483150.,
      1290394., 1301020., 1548743., 1561826., 1107225., 1116990.,
      2096794., 2115484., 2470727., 2493218., 1738905., 1755390.,
      827944.,  841504.,  956732.,  972944.,  648900.,  660720.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1030127., 1037918., 1106959.,
                                         1115534., 1952111., 1969310.,
                                         2028943., 2046926.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      997990.,  1001260., 1004530., 1007800., 1273265., 1277570., 1281875.,
      1286180., 956175.,  959550.,  962925.,  966300.,  2570162., 2580788.,
      2591414., 2602040., 3084403., 3097486., 3110569., 3123652., 2204685.,
      2214450., 2224215., 2233980., 4174898., 4193588., 4212278., 4230968.,
      4918963., 4941454., 4963945., 4986436., 3461325., 3477810., 3494295.,
      3510780., 1642328., 1655888., 1669448., 1683008., 1897252., 1913464.,
      1929676., 1945888., 1285980., 1297800., 1309620., 1321440.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2052463., 2060254., 2068045., 2075836., 2205343., 2213918.,
      2222493., 2231068., 3887023., 3904222., 3921421., 3938620.,
      4039903., 4057886., 4075869., 4093852.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2001380., 2554930., 1919750., 5174428., 6211534., 4441850.,
      8416156., 9918286., 6982010., 3336112., 3856216., 2617160.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4126486., 4435382., 7833238.,
                                         8142134.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3989740.,  4002760.,  5092710.,  5109860.,  3826050., 3839500.,
      10306436., 10348856., 12370834., 12423068., 8844710., 8883700.,
      8401796.,  8451896.,  8998802.,  9055900.,  5149094., 5186292.,
      1309616.,  1326944.,  1429912.,  1447600.,  935432.,  943760.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8221906.,  8252972.,  8836562.,
                                         8870764.,  15597778., 15666476.,
                                         16212434., 16284268.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2827004.,  2840024.,  2853044.,  2866064.,  3789774.,  3806924.,
      3824074.,  3841224.,  3117690.,  3131140.,  3144590.,  3158040.,
      9532756.,  9575176.,  9617596.,  9660016.,  11626266., 11678500.,
      11730734., 11782968., 8804094.,  8843084.,  8882074.,  8921064.,
      12400468., 12450568., 12500668., 12550768., 14969882., 15026980.,
      15084078., 15141176., 8623614.,  8660812.,  8698010.,  8735208.,
      2601904.,  2619232.,  2636560.,  2653888.,  2842136.,  2859824.,
      2877512.,  2895200.,  1862536.,  1870864.,  1879192.,  1887520.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7109706.,  7140772.,  7171838.,  7202904.,  7778826.,  7813028.,
      7847230.,  7881432.,  15139146., 15207844., 15276542., 15345240.,
      14290698., 14356388., 14422078., 14487768.};
  const std::array<int, 4> in_shape = {{1, 14, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30525.,  45080.,  49560.,  28650.,  80220., 112504., 117404., 65296.,
      131180., 181104., 186004., 102144., 53330., 71344.,  72968.,  38068.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {75754., 80654., 144354., 149254.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60275.,  61050.,  88970.,  90160.,  97790.,  99120.,  56490.,  57300.,
      157885., 160440., 221284., 225008., 230888., 234808., 128282., 130592.,
      257845., 262360., 355740., 362208., 365344., 372008., 200410., 204288.,
      103380., 106660., 138012., 142688., 141148., 145936., 73360.,  76136.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {149254., 151508., 158858., 161308.,
                                         283710., 288708., 293314., 298508.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119775., 120550., 121325., 122100., 176750., 177940., 179130., 180320.,
      194250., 195580., 196910., 198240., 112170., 112980., 113790., 114600.,
      313215., 315770., 318325., 320880., 438844., 442568., 446292., 450016.,
      457856., 461776., 465696., 469616., 254254., 256564., 258874., 261184.,
      511175., 515690., 520205., 524720., 705012., 711480., 717948., 724416.,
      724024., 730688., 737352., 744016., 396942., 400820., 404698., 408576.,
      203480., 206760., 210040., 213320., 271348., 276024., 280700., 285376.,
      277508., 282296., 287084., 291872., 143944., 146720., 149496., 152272.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296254., 298508., 300762., 303016., 315266., 317716., 320166., 322616.,
      562422., 567420., 572418., 577416., 581434., 586628., 591822., 597016.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {241025.,  356055.,  391615.,  226380.,
                                         634865.,  890183.,  928991.,  516460.,
                                         1038625., 1433495., 1472303., 808108.,
                                         419480.,  560616.,  573384.,  298592.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {599123., 637931., 1142435., 1181243.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      478975.,  482050.,  707385.,  712110.,  777945.,  783230.,  449540.,
      452760.,  1259545., 1269730., 1765519., 1780366., 1842351., 1857982.,
      1023708., 1032920., 2059225., 2077250., 2841167., 2866990., 2917999.,
      2944606., 1600732., 1616216., 825860.,  838960.,  1102556., 1121232.,
      1127644., 1146768., 586096.,  597184.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1189279., 1198246., 1266111.,
                                         1275862., 2264927., 2284870.,
                                         2341759., 2362486.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      954875.,  957950.,  961025.,  964100.,  1410045., 1414770., 1419495.,
      1424220., 1550605., 1555890., 1561175., 1566460., 895860.,  899080.,
      902300.,  905520.,  2508905., 2519090., 2529275., 2539460., 3516191.,
      3531038., 3545885., 3560732., 3669071., 3684702., 3700333., 3715964.,
      2038204., 2047416., 2056628., 2065840., 4100425., 4118450., 4136475.,
      4154500., 5656511., 5682334., 5708157., 5733980., 5809391., 5835998.,
      5862605., 5889212., 3185980., 3201464., 3216948., 3232432., 1638620.,
      1651720., 1664820., 1677920., 2186436., 2205112., 2223788., 2242464.,
      2236164., 2255288., 2274412., 2293536., 1161104., 1172192., 1183280.,
      1194368.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2369591., 2378558., 2387525., 2396492., 2522471., 2532222.,
      2541973., 2551724., 4509911., 4529854., 4549797., 4569740.,
      4662791., 4683518., 4704245., 4724972.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1915550., 2830170., 3113530., 1799800.,  5051410.,  7082166.,
      7391062., 4108104., 8265810., 11406710., 11715606., 6428744.,
      3327240., 4444440., 4545688., 2364960.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4765446., 5074342., 9089990.,
                                         9398886.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3818850.,  3831100.,  5641510.,  5660340.,  6205990.,  6227060.,
      3586760.,  3599600.,  10062150., 10102820., 14105042., 14164332.,
      14719698., 14782124., 8179416.,  8216208.,  5449542.,  5484708.,
      6653906.,  6699756.,  7268562.,  7317548.,  4013784.,  4042896.,
      1686920.,  1698320.,  2391704.,  2409008.,  2592408.,  2611504.,
      1408800.,  1420352.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9495122.,  9530892., 10109778.,
                                         10148684., 9646162., 9701260.,
                                         9081170.,  9135308.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME1x14x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2619114.,  2631364.,  2643614.,  2655864.,  4123838.,  4142668.,
      4161498.,  4180328.,  4693502.,  4714572.,  4735642.,  4756712.,
      3154792.,  3167632.,  3180472.,  3193312.,  9113518.,  9154188.,
      9194858.,  9235528.,  13211658., 13270948., 13330238., 13389528.,
      13880778., 13943204., 14005630., 14068056., 8646136.,  8682928.,
      8719720.,  8756512.,  7561518.,  7596684.,  7631850.,  7667016.,
      8349834.,  8395684.,  8441534.,  8487384.,  9018954.,  9067940.,
      9116926.,  9165912.,  5041144.,  5070256.,  5099368.,  5128480.,
      3362440.,  3373840.,  3385240.,  3396640.,  4766104.,  4783408.,
      4800712.,  4818016.,  5165720.,  5184816.,  5203912.,  5223008.,
      2806048.,  2817600.,  2829152.,  2840704.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID1x14x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8193258.,  8229028.,  8264798.,  8300568.,  8862378.,  8901284.,
      8940190.,  8979096.,  13260138., 13315236., 13370334., 13425432.,
      13671210., 13725348., 13779486., 13833624.};
  const std::array<int, 4> in_shape = {{1, 14, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24525.,  36890.,  27925.,  63630.,  90013.,  64610.,  47125.,
      64750.,  45125.,  124350., 172410., 121700., 173740., 238238.,
      166250., 104600., 140980., 96550.,  224175., 307930., 215475.,
      283850., 386463., 267890., 162075., 217210., 147975.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60613.,  65513.,  114513., 119413.,
                                         208838., 213738., 262738., 267638.,
                                         357063., 361963., 410963., 415863.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48425.,  49050.,  72800.,  73780.,  55075.,  55850.,  125230., 127260.,
      177037., 180026., 126980., 129220., 91975.,  94250.,  126210., 129500.,
      87825.,  90250.,  245050., 248700., 339605., 344820., 239600., 243400.,
      341215., 347480., 467558., 476476., 326025., 332500., 203900., 209200.,
      274435., 281960., 187650., 193100., 441675., 448350., 606410., 615860.,
      424125., 430950., 557200., 567700., 758079., 772926., 525070., 535780.,
      315825., 324150., 422660., 434420., 287475., 295950.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119413., 121226., 129017., 131026., 225057., 229026., 234661., 238826.,
      409934., 417676., 419538., 427476., 515578., 525476., 525182., 535276.,
      700455., 714126., 710059., 723926., 806099., 821926., 815703., 831726.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      96225.,   96850.,   97475.,   98100.,   144620.,  145600.,  146580.,
      147560.,  109375.,  110150.,  110925.,  111700.,  248430.,  250460.,
      252490.,  254520.,  351085.,  354074.,  357063.,  360052.,  251720.,
      253960.,  256200.,  258440.,  181675.,  183950.,  186225.,  188500.,
      249130.,  252420.,  255710.,  259000.,  173225.,  175650.,  178075.,
      180500.,  486450.,  490100.,  493750.,  497400.,  673995.,  679210.,
      684425.,  689640.,  475400.,  479200.,  483000.,  486800.,  676165.,
      682430.,  688695.,  694960.,  926198.,  935116.,  944034.,  952952.,
      645575.,  652050.,  658525.,  665000.,  402500.,  407800.,  413100.,
      418400.,  541345.,  548870.,  556395.,  563920.,  369850.,  375300.,
      380750.,  386200.,  876675.,  883350.,  890025.,  896700.,  1203370.,
      1212820., 1222270., 1231720., 841425.,  848250.,  855075.,  861900.,
      1103900., 1114400., 1124900., 1135400., 1501311., 1516158., 1531005.,
      1545852., 1039430., 1050140., 1060850., 1071560., 623325.,  631650.,
      639975.,  648300.,  833560.,  845320.,  857080.,  868840.,  566475.,
      574950.,  583425.,  591900.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237013.,  238826.,  240639.,  242452.,  256025.,  258034.,  260043.,
      262052.,  446145.,  450114.,  454083.,  458052.,  465157.,  469322.,
      473487.,  477652.,  812126.,  819868.,  827610.,  835352.,  831138.,
      839076.,  847014.,  854952.,  1021258., 1031156., 1041054., 1050952.,
      1040270., 1050364., 1060458., 1070552., 1387239., 1400910., 1414581.,
      1428252., 1406251., 1420118., 1433985., 1447852., 1596371., 1612198.,
      1628025., 1643852., 1615383., 1631406., 1647429., 1663452.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193325.,  290955.,  220325.,  503195.,  711725.,  510755.,  371525.,
      510195.,  355325.,  985875.,  1366645., 964475.,  1375605., 1885667.,
      1315405., 825275.,  1111565., 760675.,  1778425., 2442335., 1708625.,
      2248015., 3059609., 2120055., 1279025., 1712935., 1166025.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      478877.,  517685.,  905765.,  944573.,  1652819., 1691627.,
      2079707., 2118515., 2826761., 2865569., 3253649., 3292457.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      384175.,  386650.,  578025.,  581910.,  437575.,  440650.,  998305.,
      1006390., 1411543., 1423450., 1012585., 1021510., 733975.,  743050.,
      1007265., 1020390., 700975.,  710650.,  1957175., 1971750., 2712465.,
      2733290., 1913775., 1928950., 2726185., 2751210., 3735711., 3771334.,
      2604945., 2630810., 1629375., 1650550., 2193065., 2223130., 1499575.,
      1521350., 3530175., 3556850., 4846905., 4884670., 3389975., 3417250.,
      4454065., 4496030., 6059879., 6119218., 4197305., 4240110., 2524775.,
      2558050., 3378865., 3425870., 2298175., 2332050.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      950551.,  957754.,  1027383., 1035370., 1795703., 1811530.,
      1872535., 1889146., 3274719., 3305638., 3351551., 3383254.,
      4119871., 4159414., 4196703., 4237030., 5598887., 5653522.,
      5675719., 5731138., 6444039., 6507298., 6520871., 6584914.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      765875.,   768350.,  770825.,  773300.,  1152165.,  1156050.,  1159935.,
      1163820.,  872075.,  875150.,  878225.,  881300.,   1988525.,  1996610.,
      2004695.,  2012780., 2811179., 2823086., 2834993.,  2846900.,  2016245.,
      2025170.,  2034095., 2043020., 1458875., 1467950.,  1477025.,  1486100.,
      2001405.,  2014530., 2027655., 2040780., 1392275.,  1401950.,  1411625.,
      1421300.,  3899775., 3914350., 3928925., 3943500.,  5404105.,  5424930.,
      5445755.,  5466580., 3812375., 3827550., 3842725.,  3857900.,  5427345.,
      5452370.,  5477395., 5502420., 7435799., 7471422.,  7507045.,  7542668.,
      5184025.,  5209890., 5235755., 5261620., 3237575.,  3258750.,  3279925.,
      3301100.,  4356065., 4386130., 4416195., 4446260.,  2977375.,  2999150.,
      3020925.,  3042700., 7033675., 7060350., 7087025.,  7113700.,  9656045.,
      9693810.,  9731575., 9769340., 6752675., 6779950.,  6807225.,  6834500.,
      8866165.,  8908130., 8950095., 8992060., 12060419., 12119758., 12179097.,
      12238436., 8351805., 8394610., 8437415., 8480220.,  5016275.,  5049550.,
      5082825.,  5116100., 6710725., 6757730., 6804735.,  6851740.,  4562475.,
      4596350.,  4630225., 4664100.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1893899.,  1901102.,  1908305.,  1915508.,  2046779.,  2054766.,
      2062753.,  2070740.,  3575579.,  3591406.,  3607233.,  3623060.,
      3728459.,  3745070.,  3761681.,  3778292.,  6518519.,  6549438.,
      6580357.,  6611276.,  6671399.,  6703102.,  6734805.,  6766508.,
      8200199.,  8239742.,  8279285.,  8318828.,  8353079.,  8393406.,
      8433733.,  8474060.,  11143139., 11197774., 11252409., 11307044.,
      11296019., 11351438., 11406857., 11462276., 12824819., 12888078.,
      12951337., 13014596., 12977699., 13041742., 13105785., 13169828.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1535150.,  2311050., 1750350., 4002250.,  5660382., 4061610.,  2950350.,
      4050410.,  2819950., 7851350., 10882690., 7679350., 10947650., 15004486.,
      10464930., 6556150., 8827490., 6038550.,  3540478., 3694970.,  2426270.,
      3198650.,  4579246., 3320730., 2533150.,  3497690., 2447550.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3807006., 4115902., 7204862., 7513758., 3474310., 3615270.,
      6664294., 6973190., 3145710., 3242638., 6123726., 6432622.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3060450., 3070300.,  4606630.,  4622100., 3488450., 3500700.,  7972230.,
      8004500., 11273234., 11320764., 8087590., 8123220., 5864450.,  5900700.,
      8048390., 8100820.,  5601250.,  5639900., 3847970., 3865260.,  4970470.,
      4992260., 3042818.,  3054316.,  7172550., 7200900., 10197586., 10239628.,
      7350630., 7382340.,  5450050.,  5483500., 7499590., 7548100.,  5231650.,
      5267500., 4324194.,  4344828.,  4990246., 5014260., 3473730.,  3490620.,
      6372870., 6397300.,  9121938.,  9158492., 6613670., 6641460.,  5035650.,
      5066300., 6950790.,  6995380.,  4862050., 4895100.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7585298.,  7614012.,  8199954.,  8231804.,  14346514., 14409724.,
      14961170., 15027516., 6911058.,  6948620.,  7198034.,  7230540.,
      13270866., 13328588., 13885522., 13946380., 6253202.,  6291420.,
      6450066.,  6485276.,  12195218., 12247452., 12809874., 12865244.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2112330.,  2122180.,  2132030.,  2141880.,  3409118.,  3424588.,
      3440058.,  3455528.,  2836906.,  2849156.,  2861406.,  2873656.,
      7227646.,  7259916.,  7292186.,  7324456.,  10582650., 10630180.,
      10677710., 10725240., 8046878.,  8082508.,  8118138.,  8153768.,
      8900202.,  8936452.,  8972702.,  9008952.,  13153598., 13206028.,
      13258458., 13310888., 10175690., 10214340., 10252990., 10291640.,
      4425402.,  4442692.,  4459982.,  4477272.,  5105326.,  5127116.,
      5148906.,  5170696.,  2577178.,  2588676.,  2600174.,  2611672.,
      6377678.,  6406028.,  6434378.,  6462728.,  9411690.,  9453732.,
      9495774.,  9537816.,  7207662.,  7239372.,  7271082.,  7302792.,
      8246234.,  8279684.,  8313134.,  8346584.,  12231950., 12280460.,
      12328970., 12377480., 9496634.,  9532484.,  9568334.,  9604184.,
      6119978.,  6140612.,  6161246.,  6181880.,  6117502.,  6141516.,
      6165530.,  6189544.,  4064394.,  4081284.,  4098174.,  4115064.,
      5527710.,  5552140.,  5576570.,  5601000.,  8240730.,  8277284.,
      8313838.,  8350392.,  6368446.,  6396236.,  6424026.,  6451816.,
      7592266.,  7622916.,  7653566.,  7684216.,  11310302., 11354892.,
      11399482., 11444072., 8817578.,  8850628.,  8883678.,  8916728.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6567930.,  6596644.,  6625358.,  6654072.,  7237050.,  7268900.,
      7300750.,  7332600.,  13928250., 13991460., 14054670., 14117880.,
      14597370., 14663716., 14730062., 14796408., 6185450.,  6223012.,
      6260574.,  6298136.,  6207402.,  6239908.,  6272414.,  6304920.,
      12757290., 12815012., 12872734., 12930456., 13426410., 13487268.,
      13548126., 13608984., 5843930.,  5882148.,  5920366.,  5958584.,
      5683610.,  5718820.,  5754030.,  5789240.,  11586330., 11638564.,
      11690798., 11743032., 12255450., 12310820., 12366190., 12421560.};
  const std::array<int, 4> in_shape = {{3, 11, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31940.,  40740.,  30600.,  82243.,  98735.,  70630.,  60350.,
      70910.,  49300.,  160640., 188580., 132900., 223615., 260435.,
      181510., 133610., 154070., 105400., 289340., 336420., 235200.,
      364987., 422135., 292390., 206870., 237230., 161500.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65660.,  70560.,  124460., 129360.,
                                         227360., 232260., 286160., 291060.,
                                         389060., 393960., 447860., 452760.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63055.,  63880.,  80395.,  81480.,  60350.,  61200.,  161819., 164486.,
      194187., 197470., 138810., 141260., 117715., 120700., 138215., 141820.,
      95950.,  98600.,  316495., 321280., 371455., 377160., 261650., 265800.,
      439019., 447230., 511119., 520870., 355950., 363020., 260275., 267220.,
      299915., 308140., 204850., 210800., 569935., 578680., 662515., 672840.,
      462950., 470400., 716219., 729974., 828051., 844270., 573090., 584780.,
      402835., 413740., 461615., 474460., 313750., 323000.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129360., 131320., 138964., 141120., 244608., 248920., 254212., 258720.,
      446292., 454720., 455896., 464520., 561540., 572320., 571144., 582120.,
      763224., 778120., 772828., 787920., 878472., 895720., 888076., 905520.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      125285.,  126110.,  126935.,  127760.,  159705.,  160790.,  161875.,
      162960.,  119850.,  120700.,  121550.,  122400.,  320971.,  323638.,
      326305.,  328972.,  385091.,  388374.,  391657.,  394940.,  275170.,
      277620.,  280070.,  282520.,  232445.,  235430.,  238415.,  241400.,
      272825.,  276430.,  280035.,  283640.,  189250.,  191900.,  194550.,
      197200.,  628205.,  632990.,  637775.,  642560.,  737205.,  742910.,
      748615.,  754320.,  519150.,  523300.,  527450.,  531600.,  869827.,
      878038.,  886249.,  894460.,  1012487., 1022238., 1031989., 1041740.,
      704830.,  711900.,  718970.,  726040.,  513605.,  520550.,  527495.,
      534440.,  591605.,  599830.,  608055.,  616280.,  403750.,  409700.,
      415650.,  421600.,  1131125., 1139870., 1148615., 1157360., 1314705.,
      1325030., 1335355., 1345680., 918450.,  925900.,  933350.,  940800.,
      1418683., 1432438., 1446193., 1459948., 1639883., 1656102., 1672321.,
      1688540., 1134490., 1146180., 1157870., 1169560., 794765.,  805670.,
      816575.,  827480.,  910385.,  923230.,  936075.,  948920.,  618250.,
      627500.,  636750.,  646000.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      256760.,  258720.,  260680.,  262640.,  275772.,  277928.,  280084.,
      282240.,  484904.,  489216.,  493528.,  497840.,  503916.,  508424.,
      512932.,  517440.,  884156.,  892584.,  901012.,  909440.,  903168.,
      911792.,  920416.,  929040.,  1112300., 1123080., 1133860., 1144640.,
      1131312., 1142288., 1153264., 1164240., 1511552., 1526448., 1541344.,
      1556240., 1530564., 1545656., 1560748., 1575840., 1739696., 1756944.,
      1774192., 1791440., 1758708., 1776152., 1793596., 1811040.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      251950.,  321545.,  241575.,  650510.,  780913.,  558495.,  475750.,
      558845.,  388275.,  1273630., 1495025., 1053375., 1770398., 2061577.,
      1436295., 1053910., 1214885., 830475.,  2295310., 2668505., 1865175.,
      2890286., 3342241., 2314095., 1632070., 1870925., 1272675.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      518959.,  557767.,  984655.,  1023463., 1799623., 1838431.,
      2265319., 2304127., 3080287., 3119095., 3545983., 3584791.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      500630.,  503900.,  638785.,  643090.,  479775.,  483150.,  1290394.,
      1301020., 1548743., 1561826., 1107225., 1116990., 939590.,  951500.,
      1103305., 1117690., 765975.,  776550.,  2528150., 2547260., 2967265.,
      2990050., 2090175., 2106750., 3507994., 3540796., 4084199., 4123154.,
      2844345., 2872590., 2080070., 2107820., 2396905., 2429770., 1637175.,
      1660950., 4555670., 4590620., 5295745., 5337010., 3700575., 3730350.,
      5725594., 5780572., 6619655., 6684482., 4581465., 4628190., 3220550.,
      3264140., 3690505., 3741850., 2508375., 2545350.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1030127., 1037918., 1106959., 1115534., 1952111., 1969310.,
      2028943., 2046926., 3565583., 3599246., 3642415., 3676862.,
      4487567., 4530638., 4564399., 4608254., 6101039., 6160574.,
      6177871., 6238190., 7023023., 7091966., 7099855., 7169582.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      997990.,   1001260.,  1004530.,  1007800.,  1273265.,  1277570.,
      1281875.,  1286180.,  956175.,   959550.,   962925.,   966300.,
      2570162.,  2580788.,  2591414.,  2602040.,  3084403.,  3097486.,
      3110569.,  3123652.,  2204685.,  2214450.,  2224215.,  2233980.,
      1867270.,  1879180.,  1891090.,  1903000.,  2192225.,  2206610.,
      2220995.,  2235380.,  1521375.,  1531950.,  1542525.,  1553100.,
      5037190.,  5056300.,  5075410.,  5094520.,  5911745.,  5934530.,
      5957315.,  5980100.,  4163775.,  4180350.,  4196925.,  4213500.,
      6983186.,  7015988.,  7048790.,  7081592.,  8129443.,  8168398.,
      8207353.,  8246308.,  5660445.,  5688690.,  5716935.,  5745180.,
      4132390.,  4160140.,  4187890.,  4215640.,  4760945.,  4793810.,
      4826675.,  4859540.,  3250575.,  3274350.,  3298125.,  3321900.,
      9076390.,  9111340.,  9146290.,  9181240.,  10550225., 10591490.,
      10632755., 10674020., 7371375.,  7401150.,  7430925.,  7460700.,
      11396210., 11451188., 11506166., 11561144., 13174483., 13239310.,
      13304137., 13368964., 9116205.,  9162930.,  9209655.,  9256380.,
      6397510.,  6441100.,  6484690.,  6528280.,  7329665.,  7381010.,
      7432355.,  7483700.,  4979775.,  5016750.,  5053725.,  5090700.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2052463.,  2060254.,  2068045.,  2075836.,  2205343.,  2213918.,
      2222493.,  2231068.,  3887023.,  3904222.,  3921421.,  3938620.,
      4039903.,  4057886.,  4075869.,  4093852.,  7097503.,  7131166.,
      7164829.,  7198492.,  7250383.,  7284830.,  7319277.,  7353724.,
      8932063.,  8975134.,  9018205.,  9061276.,  9084943.,  9128798.,
      9172653.,  9216508.,  12142543., 12202078., 12261613., 12321148.,
      12295423., 12355742., 12416061., 12476380., 13977103., 14046046.,
      14114989., 14183932., 14129983., 14199710., 14269437., 14339164.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2001380.,  2554930., 1919750.,  5174428.,  6211534., 4441850.,  3777860.,
      4437090.,  3081750., 10143140., 11905810., 8387750., 14089180., 16405102.,
      11427290., 7253252., 6490434.,  4084150.,  2494820., 3121650.,  2311750.,
      5714716.,  6829326., 4865210.,  4056260.,  4752930., 3294550.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4126486.,  4435382.,  7833238., 8142134., 14320054., 14628950.,
      15685942., 13103062., 4744278., 5053174., 8451030.,  8759926.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3989740.,  4002760.,  5092710.,  5109860.,  3826050., 3839500.,
      10306436., 10348856., 12370834., 12423068., 8844710., 8883700.,
      7508140.,  7555720.,  7702598.,  7755972.,  4089634., 4123692.,
      4481260.,  4496200.,  5657190.,  5676580.,  4216450., 4231500.,
      10844036., 10889144., 12985490., 13040860., 9265830., 9307060.,
      6670508.,  6715912.,  5984582.,  6032004.,  3833890., 3867500.,
      4972780.,  4989640.,  6221670.,  6243300.,  4606850., 4623500.,
      11381636., 11429432., 13600146., 13658652., 9686950., 9730420.,
      4915372.,  4954504.,  5831238.,  5878852.,  4045090., 4080300.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8221906.,  8252972.,  8836562.,  8870764.,  15597778., 15666476.,
      13877714., 13943404., 8836562.,  8870764.,  9451218.,  9488556.,
      13877714., 13943404., 11608786., 11669420., 9451218.,  9488556.,
      10065874., 10106348., 11608786., 11669420., 12223442., 12287212.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2827004.,  2840024.,  2853044.,  2866064.,  3789774.,  3806924.,
      3824074.,  3841224.,  3117690.,  3131140.,  3144590.,  3158040.,
      9532756.,  9575176.,  9617596.,  9660016.,  11626266., 11678500.,
      11730734., 11782968., 8804094.,  8843084.,  8882074.,  8921064.,
      11905916., 11953496., 12001076., 12048656., 14287886., 14341260.,
      14394634., 14448008., 8115514.,  8149572.,  8183630.,  8217688.,
      3316604.,  3331544.,  3346484.,  3361424.,  4359438.,  4378828.,
      4398218.,  4417608.,  3536442.,  3551492.,  3566542.,  3581592.,
      10113748., 10158856., 10203964., 10249072., 12295386., 12350756.,
      12406126., 12461496., 9283646.,  9324876.,  9366106.,  9407336.,
      12231676., 12277080., 12322484., 12367888., 11808078., 11855500.,
      11902922., 11950344., 7571706.,  7605316.,  7638926.,  7672536.,
      3806204.,  3823064.,  3839924.,  3856784.,  4929102.,  4950732.,
      4972362.,  4993992.,  3955194.,  3971844.,  3988494.,  4005144.,
      10694740., 10742536., 10790332., 10838128., 12964506., 13023012.,
      13081518., 13140024., 9763198.,  9806668.,  9850138.,  9893608.,
      9677948.,  9717080.,  9756212.,  9795344.,  11402894., 11450508.,
      11498122., 11545736., 7959738.,  7994948.,  8030158.,  8065368.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7109706.,  7140772.,  7171838.,  7202904.,  7778826.,  7813028.,
      7847230.,  7881432.,  15139146., 15207844., 15276542., 15345240.,
      14290698., 14356388., 14422078., 14487768., 7778826.,  7813028.,
      7847230.,  7881432.,  8447946.,  8485284.,  8522622.,  8559960.,
      14290698., 14356388., 14422078., 14487768., 13395146., 13455780.,
      13516414., 13577048., 8447946.,  8485284.,  8522622.,  8559960.,
      9117066.,  9157540.,  9198014.,  9238488.,  13395146., 13455780.,
      13516414., 13577048., 14064266., 14128036., 14191806., 14255576.};
  const std::array<int, 4> in_shape = {{3, 11, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30525.,  45080.,  49560.,  28650.,  80220.,  112504., 117404., 65296.,
      59575.,  81340.,  83860.,  45030.,  157575., 217560., 222040., 122590.,
      220360., 301154., 306054., 166628., 132725., 178360., 180880., 95850.,
      284625., 390040., 394520., 216530., 360500., 489804., 494704., 267960.,
      205875., 275380., 277900., 146670.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {75754.,  80654.,  144354., 149254.,
                                         264404., 269304., 333004., 337904.,
                                         453054., 457954., 521654., 526554.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60275.,  61050.,  88970.,  90160.,  97790.,  99120.,  56490.,  57300.,
      157885., 160440., 221284., 225008., 230888., 234808., 128282., 130592.,
      116275., 119150., 158550., 162680., 163450., 167720., 87570.,  90060.,
      310525., 315150., 428540., 435120., 437360., 444080., 241290., 245180.,
      432775., 440720., 591038., 602308., 600642., 612108., 326634., 333256.,
      258725., 265450., 347200., 356720., 352100., 361760., 186130., 191700.,
      560775., 569250., 768110., 780080., 776930., 789040., 426090., 433060.,
      707665., 721000., 960792., 979608., 970396., 989408., 524986., 535920.,
      401175., 411750., 535850., 550760., 540750., 555800., 284690., 293340.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149254., 151508., 158858.,  161308.,  283710.,  288708.,
      293314., 298508., 519008.,  528808.,  528612.,  538608.,
      653464., 666008., 663068.,  675808.,  888762.,  906108.,
      898366., 915908., 1023218., 1043308., 1032822., 1053108.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119775.,  120550.,  121325.,  122100.,  176750.,  177940.,  179130.,
      180320.,  194250.,  195580.,  196910.,  198240.,  112170.,  112980.,
      113790.,  114600.,  313215.,  315770.,  318325.,  320880.,  438844.,
      442568.,  446292.,  450016.,  457856.,  461776.,  465696.,  469616.,
      254254.,  256564.,  258874.,  261184.,  229675.,  232550.,  235425.,
      238300.,  312970.,  317100.,  321230.,  325360.,  322630.,  326900.,
      331170.,  335440.,  172650.,  175140.,  177630.,  180120.,  616425.,
      621050.,  625675.,  630300.,  850500.,  857080.,  863660.,  870240.,
      868000.,  874720.,  881440.,  888160.,  478690.,  482580.,  486470.,
      490360.,  857605.,  865550.,  873495.,  881440.,  1170806., 1182076.,
      1193346., 1204616., 1189818., 1201284., 1212750., 1224216., 646646.,
      653268.,  659890.,  666512.,  510725.,  517450.,  524175.,  530900.,
      684880.,  694400.,  703920.,  713440.,  694540.,  704200.,  713860.,
      723520.,  366690.,  372260.,  377830.,  383400.,  1113075., 1121550.,
      1130025., 1138500., 1524250., 1536220., 1548190., 1560160., 1541750.,
      1553860., 1565970., 1578080., 845210.,  852180.,  859150.,  866120.,
      1401995., 1415330., 1428665., 1442000., 1902768., 1921584., 1940400.,
      1959216., 1921780., 1940792., 1959804., 1978816., 1039038., 1049972.,
      1060906., 1071840., 791775.,  802350.,  812925.,  823500.,  1056790.,
      1071700., 1086610., 1101520., 1066450., 1081500., 1096550., 1111600.,
      560730.,  569380.,  578030.,  586680.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296254.,  298508.,  300762.,  303016.,  315266.,  317716.,  320166.,
      322616.,  562422.,  567420.,  572418.,  577416.,  581434.,  586628.,
      591822.,  597016.,  1028216., 1038016., 1047816., 1057616., 1047228.,
      1057224., 1067220., 1077216., 1294384., 1306928., 1319472., 1332016.,
      1313396., 1326136., 1338876., 1351616., 1760178., 1777524., 1794870.,
      1812216., 1779190., 1796732., 1814274., 1831816., 2026346., 2046436.,
      2066526., 2086616., 2045358., 2065644., 2085930., 2106216.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241025.,  356055.,  391615.,  226380.,  634865.,  890183.,
      928991.,  516460.,  469925.,  641235.,  661115.,  354620.,
      1249725., 1725115., 1760675., 971740.,  1745205., 2384291.,
      2423099., 1318492., 1047425., 1406615., 1426495., 755020.,
      2258425., 3094175., 3129735., 1717100., 2855545., 3878399.,
      3917207., 2120524., 1624925., 2171995., 2191875., 1155420.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      599123.,  637931.,  1142435., 1181243., 2093231., 2132039.,
      2636543., 2675351., 3587339., 3626147., 4130651., 4169459.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      478975.,  482050.,  707385.,  712110.,  777945.,  783230.,  449540.,
      452760.,  1259545., 1269730., 1765519., 1780366., 1842351., 1857982.,
      1023708., 1032920., 928375.,  939850.,  1265985., 1282470., 1305185.,
      1322230., 699300.,  709240.,  2480975., 2499450., 3423945., 3450230.,
      3494505., 3521350., 1927940., 1943480., 3458665., 3490410., 4723551.,
      4768582., 4800383., 4846198., 2610524., 2636984., 2067975., 2094850.,
      2775185., 2813230., 2814385., 2852990., 1487780., 1510040., 4482975.,
      4516850., 6140505., 6188350., 6211065., 6259470., 3406340., 3434200.,
      5657785., 5711090., 7681583., 7756798., 7758415., 7834414., 4197340.,
      4241048., 3207575., 3249850., 4284385., 4343990., 4323585., 4383750.,
      2276260., 2310840.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1189279., 1198246., 1266111., 1275862., 2264927., 2284870.,
      2341759., 2362486., 4147311., 4186462., 4224143., 4264078.,
      5222959., 5273086., 5299791., 5350702., 7105343., 7174678.,
      7182175., 7252294., 8180991., 8261302., 8257823., 8338918.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      954875.,   957950.,   961025.,   964100.,   1410045.,  1414770.,
      1419495.,  1424220.,  1550605.,  1555890.,  1561175.,  1566460.,
      895860.,   899080.,   902300.,   905520.,   2508905.,  2519090.,
      2529275.,  2539460.,  3516191.,  3531038.,  3545885.,  3560732.,
      3669071.,  3684702.,  3700333.,  3715964.,  2038204.,  2047416.,
      2056628.,  2065840.,  1845275.,  1856750.,  1868225.,  1879700.,
      2515485.,  2531970.,  2548455.,  2564940.,  2593325.,  2610370.,
      2627415.,  2644460.,  1388660.,  1398600.,  1408540.,  1418480.,
      4943475.,  4961950.,  4980425.,  4998900.,  6821605.,  6847890.,
      6874175.,  6900460.,  6962165.,  6989010.,  7015855.,  7042700.,
      3840340.,  3855880.,  3871420.,  3886960.,  6885585.,  6917330.,
      6949075.,  6980820.,  9402071.,  9447102.,  9492133.,  9537164.,
      9554951.,  9600766.,  9646581.,  9692396.,  5194588.,  5221048.,
      5247508.,  5273968.,  4109075.,  4135950.,  4162825.,  4189700.,
      5512325.,  5550370.,  5588415.,  5626460.,  5590165.,  5628770.,
      5667375.,  5705980.,  2953300.,  2975560.,  2997820.,  3020080.,
      8932075.,  8965950.,  8999825.,  9033700.,  12233165., 12281010.,
      12328855., 12376700., 12373725., 12422130., 12470535., 12518940.,
      6784820.,  6812680.,  6840540.,  6868400.,  11262265., 11315570.,
      11368875., 11422180., 15287951., 15363166., 15438381., 15513596.,
      15440831., 15516830., 15592829., 15668828., 8350972.,  8394680.,
      8438388.,  8482096.,  6372875.,  6415150.,  6457425.,  6499700.,
      8509165.,  8568770.,  8628375.,  8687980.,  8587005.,  8647170.,
      8707335.,  8767500.,  4517940.,  4552520.,  4587100.,  4621680.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2369591.,  2378558.,  2387525.,  2396492.,  2522471.,  2532222.,
      2541973.,  2551724.,  4509911.,  4529854.,  4549797.,  4569740.,
      4662791.,  4683518.,  4704245.,  4724972.,  8255471.,  8294622.,
      8333773.,  8372924.,  8408351.,  8448286.,  8488221.,  8528156.,
      10395791., 10445918., 10496045., 10546172., 10548671., 10599582.,
      10650493., 10701404., 14141351., 14210686., 14280021., 14349356.,
      14294231., 14364350., 14434469., 14504588., 16281671., 16361982.,
      16442293., 16522604., 16434551., 16515646., 16596741., 16677836.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1915550.,  2830170.,  3113530.,  1799800., 5051410., 7082166.,
      7391062.,  4108104.,  3732750.,  5092010., 5249930., 2814520.,
      9954350.,  13739530., 14022890., 7738040., 9389506., 10495942.,
      9621094.,  5165064.,  1801118.,  1747034., 1638714., 848504.,
      4629950.,  6513850.,  6797210.,  3804920., 8036210., 11097814.,
      11406710., 6262984.,  5282350.,  7144970., 7302890., 3887800.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4765446., 5074342., 4850630., 4567654., 6773270., 7082166.,
      3798742., 3349878., 5823782., 4850630., 3926502., 3870854.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3818850.,  3831100.,  5641510.,  5660340.,  6205990.,  6227060.,
      3586760.,  3599600.,  10062150., 10102820., 14105042., 14164332.,
      14719698., 14782124., 8179416.,  8216208.,  3454722.,  3484188.,
      3695622.,  3732820.,  4009222.,  4048660.,  2115912.,  2139248.,
      6522850.,  6545500.,  9310630.,  9344020.,  9875110.,  9910740.,
      5583560.,  5604720.,  8543174.,  8586116.,  9646162.,  9701260.,
      9081170.,  9135308.,  5014232.,  5046288.,  2470786.,  2494268.,
      2784902.,  2812084.,  2836358.,  2861684.,  1542472.,  1557744.,
      9226850.,  9259900.,  12979750., 13027700., 13544230., 13594420.,
      7580360.,  7609840.,  6295110.,  6334180.,  7546578.,  7597484.,
      6653906.,  6699756.,  3684056.,  3711376.,  2920450.,  2935900.,
      4159750.,  4183060.,  4473350.,  4498900.,  2476360.,  2491760.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9495122., 9530892., 10109778., 10148684., 9646162.,  9701260.,
      9081170., 9135308., 13490386., 13546540., 14105042., 14164332.,
      7546578., 7597484., 6653906.,  6699756.,  11587410., 11647564.,
      9646162., 9701260., 7806290.,  7853004.,  7700050.,  7741708.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x11x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2619114.,  2631364.,  2643614.,  2655864.,  4123838.,  4142668.,
      4161498.,  4180328.,  4693502.,  4714572.,  4735642.,  4756712.,
      3154792.,  3167632.,  3180472.,  3193312.,  9113518.,  9154188.,
      9194858.,  9235528.,  13211658., 13270948., 13330238., 13389528.,
      13880778., 13943204., 14005630., 14068056., 8646136.,  8682928.,
      8719720.,  8756512.,  6495978.,  6525444.,  6554910.,  6584376.,
      6871742.,  6908940.,  6946138.,  6983336.,  7398398.,  7437836.,
      7477274.,  7516712.,  4208488.,  4231824.,  4255160.,  4278496.,
      5247818.,  5270468.,  5293118.,  5315768.,  7826654.,  7860044.,
      7893434.,  7926824.,  8396318.,  8431948.,  8467578.,  8503208.,
      5436136.,  5457296.,  5478456.,  5499616.,  9595854.,  9638796.,
      9681738.,  9724680.,  13260138., 13315236., 13370334., 13425432.,
      13671210., 13725348., 13779486., 13833624., 9005176.,  9037232.,
      9069288.,  9101344.,  3895114.,  3918596.,  3942078.,  3965560.,
      4421342.,  4448524.,  4475706.,  4502888.,  4427806.,  4453132.,
      4478458.,  4503784.,  3069672.,  3084944.,  3100216.,  3115488.,
      7876522.,  7909572.,  7942622.,  7975672.,  11529470., 11577420.,
      11625370., 11673320., 12099134., 12149324., 12199514., 12249704.,
      7717480.,  7746960.,  7776440.,  7805920.,  9674734.,  9713804.,
      9752874.,  9791944.,  10687178., 10738084., 10788990., 10839896.,
      8349834.,  8395684.,  8441534.,  8487384.,  4645624.,  4672944.,
      4700264.,  4727584.,  4163498.,  4178948.,  4194398.,  4209848.,
      6535934.,  6559244.,  6582554.,  6605864.,  7062590.,  7088140.,
      7113690.,  7139240.,  4937320.,  4952720.,  4968120.,  4983520.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x11x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8193258.,  8229028.,  8264798.,  8300568.,  8862378.,  8901284.,
      8940190.,  8979096.,  13260138., 13315236., 13370334., 13425432.,
      13671210., 13725348., 13779486., 13833624., 12542538., 12598692.,
      12654846., 12711000., 13211658., 13270948., 13330238., 13389528.,
      10687178., 10738084., 10788990., 10839896., 8349834.,  8395684.,
      8441534.,  8487384.,  13500330., 13560484., 13620638., 13680792.,
      13260138., 13315236., 13370334., 13425432., 7589930.,  7636644.,
      7683358.,  7730072.,  6825450.,  6867108.,  6908766.,  6950424.};
  const std::array<int, 4> in_shape = {{3, 11, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      33790.,  49700.,  36910.,  73640.,  103488., 73850.,  52350.,
      71680.,  49800.,  150610., 207704., 145810., 193760., 265188.,
      184730., 115050., 154840., 105900., 267430., 365708., 254710.,
      313880., 426888., 295610., 177750., 238000., 162000.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60613.,  65513.,  114513., 119413.,
                                         222313., 227213., 276213., 281113.,
                                         384013., 388913., 437913., 442813.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      66665.,  67580.,  97993.,  99400.,  72725.,  73820.,  144865., 147280.,
      203448., 206976., 145075., 147700., 102150., 104700., 139685., 143360.,
      96900.,  99600.,  296345., 301220., 408457., 415408., 286565., 291620.,
      380485., 387520., 520380., 530376., 362215., 369460., 224250., 230100.,
      301385., 309680., 205800., 211800., 526025., 534860., 718921., 731416.,
      500405., 509420., 616105., 627760., 837312., 853776., 579355., 591220.,
      346350., 355500., 463085., 476000., 314700., 324000.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119413., 121226., 129017., 131026., 225057., 229026., 234661., 238826.,
      436345., 444626., 445949., 454426., 541989., 552426., 551593., 562226.,
      753277., 768026., 762881., 777826., 858921., 875826., 868525., 885626.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      132415.,  133330.,  134245.,  135160.,  194579.,  195986.,  197393.,
      198800.,  144355.,  145450.,  146545.,  147640.,  287315.,  289730.,
      292145.,  294560.,  403368.,  406896.,  410424.,  413952.,  287525.,
      290150.,  292775.,  295400.,  201750.,  204300.,  206850.,  209400.,
      275695.,  279370.,  283045.,  286720.,  191100.,  193800.,  196500.,
      199200.,  587815.,  592690.,  597565.,  602440.,  809963.,  816914.,
      823865.,  830816.,  568075.,  573130.,  578185.,  583240.,  753935.,
      760970.,  768005.,  775040.,  1030764., 1040760., 1050756., 1060752.,
      717185.,  724430.,  731675.,  738920.,  442650.,  448500.,  454350.,
      460200.,  594475.,  602770.,  611065.,  619360.,  405600.,  411600.,
      417600.,  423600.,  1043215., 1052050., 1060885., 1069720., 1425347.,
      1437842., 1450337., 1462832., 991795.,  1000810., 1009825., 1018840.,
      1220555., 1232210., 1243865., 1255520., 1658160., 1674624., 1691088.,
      1707552., 1146845., 1158710., 1170575., 1182440., 683550.,  692700.,
      701850.,  711000.,  913255.,  926170.,  939085.,  952000.,  620100.,
      629400.,  638700.,  648000.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237013.,  238826.,  240639.,  242452.,  256025.,  258034.,  260043.,
      262052.,  446145.,  450114.,  454083.,  458052.,  465157.,  469322.,
      473487.,  477652.,  864409.,  872690.,  880971.,  889252.,  883421.,
      891898.,  900375.,  908852.,  1073541., 1083978., 1094415., 1104852.,
      1092553., 1103186., 1113819., 1124452., 1491805., 1506554., 1521303.,
      1536052., 1510817., 1525762., 1540707., 1555652., 1700937., 1717842.,
      1734747., 1751652., 1719949., 1737050., 1754151., 1771252.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      266750.,  392434.,  291470.,  582505.,  818447.,  583905.,  412775.,
      564865.,  392175.,  1193390., 1645378., 1154750., 1534225., 2099111.,
      1461705., 907775.,  1220905., 834375.,  2120030., 2898322., 2018030.,
      2485945., 3379775., 2339505., 1402775., 1876945., 1276575.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      478877.,  517685.,  905765.,  944573.,  1759541., 1798349.,
      2186429., 2225237., 3040205., 3079013., 3467093., 3505901.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      529870.,  533500.,  779282.,  784868.,  578590.,  582940.,  1155385.,
      1165010., 1622831., 1636894., 1157345., 1167810., 815375.,  825550.,
      1115065., 1129730., 773575.,  784350.,  2367310., 2386780., 3262994.,
      3290756., 2289310., 2309500., 3040345., 3068450., 4158287., 4198222.,
      2894465., 2923410., 1792175., 1815550., 2408665., 2441810., 1644775.,
      1668750., 4204750., 4240060., 5746706., 5796644., 4000030., 4036060.,
      4925305., 4971890., 6693743., 6759550., 4631585., 4679010., 2768975.,
      2805550., 3702265., 3753890., 2515975., 2553150.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      950551.,  957754.,  1027383., 1035370., 1795703., 1811530.,
      1872535., 1889146., 3486007., 3519082., 3562839., 3596698.,
      4331159., 4372858., 4407991., 4450474., 6021463., 6080410.,
      6098295., 6158026., 6866615., 6934186., 6943447., 7011802.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1056110.,  1059740.,  1063370., 1067000., 1552978.,  1558564.,
      1564150.,  1569736.,  1152830., 1157180., 1161530.,  1165880.,
      2301145.,  2310770.,  2320395., 2330020., 3231599.,  3245662.,
      3259725.,  3273788.,  2304225., 2314690., 2325155.,  2335620.,
      1620575.,  1630750.,  1640925., 1651100., 2215465.,  2230130.,
      2244795.,  2259460.,  1536375., 1547150., 1557925.,  1568700.,
      4715150.,  4734620.,  4754090., 4773560., 6498226.,  6525988.,
      6553750.,  6581512.,  4558430., 4578620., 4598810.,  4619000.,
      6052585.,  6080690.,  6108795., 6136900., 8276639.,  8316574.,
      8356509.,  8396444.,  5759985., 5788930., 5817875.,  5846820.,
      3560975.,  3584350.,  3607725., 3631100., 4784185.,  4817330.,
      4850475.,  4883620.,  3265575., 3289550., 3313525.,  3337500.,
      8374190.,  8409500.,  8444810., 8480120., 11443474., 11493412.,
      11543350., 11593288., 7964030., 8000060., 8036090.,  8072120.,
      9804025.,  9850610.,  9897195., 9943780., 13321679., 13387486.,
      13453293., 13519100., 9215745., 9263170., 9310595.,  9358020.,
      5501375.,  5537950.,  5574525., 5611100., 7352905.,  7404530.,
      7456155.,  7507780.,  4994775., 5031950., 5069125.,  5106300.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1893899.,  1901102.,  1908305.,  1915508.,  2046779.,  2054766.,
      2062753.,  2070740.,  3575579.,  3591406.,  3607233.,  3623060.,
      3728459.,  3745070.,  3761681.,  3778292.,  6938939.,  6972014.,
      7005089.,  7038164.,  7091819.,  7125678.,  7159537.,  7193396.,
      8620619.,  8662318.,  8704017.,  8745716.,  8773499.,  8815982.,
      8858465.,  8900948.,  11983979., 12042926., 12101873., 12160820.,
      12136859., 12196590., 12256321., 12316052., 13665659., 13733230.,
      13800801., 13868372., 13818539., 13886894., 13955249., 14023604.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2119780.,  3118892., 2316580., 4633650.,  6509846., 4643730.,  3278150.,
      4484690.,  3112550., 9501220., 13098092., 9191140., 12210450., 16703414.,
      11629170., 6093542., 6538034., 4114950.,  2567140., 3723692.,  2733220.,
      5092850.,  7127638., 5067090., 3516550.,  4800530., 3325350.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3807006., 4115902., 7204862., 7513758., 4115902., 4424798.,
      7513758., 7822654., 4424798., 4733694., 7822654., 7733214.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4225100.,  4239560.,  6215524.,  6237784.,  4615820.,  4633160.,
      9228870.,  9267300.,  12963538., 13019692., 9245670.,  9287460.,
      6515650.,  6556300.,  7796678.,  7851172.,  4150434.,  4185292.,
      4670540.,  4686920.,  6817636.,  6842584.,  5030540.,  5049800.,
      9685830.,  9726500.,  13578194., 13637484., 9666790.,  9710820.,
      5638338.,  5676492.,  6078662.,  6127204.,  3894690.,  3929100.,
      5115980.,  5134280.,  7419748.,  7447384.,  5445260.,  5466440.,
      10142790., 10185700., 14192850., 14255276., 10087910., 10134180.,
      4326850.,  4360460.,  5925318.,  5974052.,  3688098.,  3722060.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7585298.,  7614012.,  8199954.,  8231804.,  14346514., 14409724.,
      14961170., 15027516., 8199954.,  8231804.,  8814610.,  8849596.,
      14961170., 15027516., 15575826., 15645308., 8814610.,  8849596.,
      9429266.,  9467388.,  15575826., 15645308., 15395858., 15466428.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3265564.,  3280024.,  3294484.,  3308944.,  5088212.,  5110472.,
      5132732.,  5154992.,  4095324.,  4112664.,  4130004.,  4147344.,
      8563310.,  8601740.,  8640170.,  8678600.,  12422730., 12478884.,
      12535038., 12591192., 9365646.,  9407436.,  9449226.,  9491016.,
      9927866.,  9968516.,  10009166., 10049816., 14474926., 14529420.,
      14583914., 14638408., 8236314.,  8271172.,  8306030.,  8340888.,
      3728540.,  3744920.,  3761300.,  3777680.,  5732692.,  5757640.,
      5782588.,  5807536.,  4562396.,  4581656.,  4600916.,  4620176.,
      9049006.,  9089676.,  9130346.,  9171016.,  13091850., 13151140.,
      13210430., 13269720., 9845198.,  9889228.,  9933258.,  9977288.,
      10174586., 10212740., 10250894., 10289048., 11995118., 12043660.,
      12092202., 12140744., 7692506.,  7726916.,  7761326.,  7795736.,
      4191516.,  4209816.,  4228116.,  4246416.,  6377172.,  6404808.,
      6432444.,  6460080.,  5029468.,  5050648.,  5071828.,  5093008.,
      9534702.,  9577612.,  9620522.,  9663432.,  13760970., 13823396.,
      13885822., 13948248., 10324750., 10371020., 10417290., 10463560.,
      8506426.,  8540036.,  8573646.,  8607256.,  11589934., 11638668.,
      11687402., 11736136., 7247002.,  7280964.,  7314926.,  7348888.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6567930.,  6596644.,  6625358.,  6654072.,  7237050.,  7268900.,
      7300750.,  7332600.,  13928250., 13991460., 14054670., 14117880.,
      14597370., 14663716., 14730062., 14796408., 7237050.,  7268900.,
      7300750.,  7332600.,  7906170.,  7941156.,  7976142.,  8011128.,
      14597370., 14663716., 14730062., 14796408., 15266490., 15335972.,
      15405454., 15474936., 7906170.,  7941156.,  7976142.,  8011128.,
      8575290.,  8613412.,  8651534.,  8689656.,  15266490., 15335972.,
      15405454., 15474936., 15396986., 15467556., 15538126., 15608696.};
  const std::array<int, 4> in_shape = {{3, 12, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      43899.,  54747.,  40410.,  95095.,  113435., 80710.,  67010.,
      78470.,  54400.,  194235., 227115., 159210., 249319., 289835.,
      201670., 146930., 169190., 115600., 344571., 399483., 278010.,
      403543., 466235., 322630., 226850., 259910., 176800.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65660.,  70560.,  124460., 129360.,
                                         242060., 246960., 300860., 305760.,
                                         418460., 423360., 477260., 482160.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      86592.,  87798.,  107940., 109494., 79620.,  80820.,  187019., 190190.,
      222999., 226870., 158550., 161420., 130675., 134020., 152915., 156940.,
      105850., 108800., 382080., 388470., 446628., 454230., 312900., 318420.,
      489419., 498638., 568743., 579670., 395430., 403340., 286195., 293860.,
      329315., 338380., 224650., 231200., 677568., 689142., 785316., 798966.,
      546180., 556020., 791819., 807086., 914487., 932470., 632310., 645260.,
      441715., 453700., 505715., 519820., 343450., 353600.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129360., 131320., 138964., 141120., 244608., 248920., 254212., 258720.,
      475104., 484120., 484708., 493920., 590352., 601720., 599956., 611520.,
      820848., 836920., 830452., 846720., 936096., 954520., 945700., 964320.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      171978.,  173184.,  174390.,  175596.,  214326.,  215880.,  217434.,
      218988.,  158040.,  159240.,  160440.,  161640.,  370867.,  374038.,
      377209.,  380380.,  442127.,  445998.,  449869.,  453740.,  314230.,
      317100.,  319970.,  322840.,  258005.,  261350.,  264695.,  268040.,
      301805.,  305830.,  309855.,  313880.,  208750.,  211700.,  214650.,
      217600.,  757770.,  764160.,  770550.,  776940.,  885654.,  893256.,
      900858.,  908460.,  620280.,  625800.,  631320.,  636840.,  969619.,
      978838.,  988057.,  997276.,  1126559., 1137486., 1148413., 1159340.,
      782950.,  790860.,  798770.,  806680.,  564725.,  572390.,  580055.,
      587720.,  649565.,  658630.,  667695.,  676760.,  442750.,  449300.,
      455850.,  462400.,  1343562., 1355136., 1366710., 1378284., 1556982.,
      1570632., 1584282., 1597932., 1082520., 1092360., 1102200., 1112040.,
      1568371., 1583638., 1598905., 1614172., 1810991., 1828974., 1846957.,
      1864940., 1251670., 1264620., 1277570., 1290520., 871445.,  883430.,
      895415.,  907400.,  997325.,  1011430., 1025535., 1039640., 676750.,
      686900.,  697050.,  707200.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      256760.,  258720.,  260680.,  262640.,  275772.,  277928.,  280084.,
      282240.,  484904.,  489216.,  493528.,  497840.,  503916.,  508424.,
      512932.,  517440.,  941192.,  950208.,  959224.,  968240.,  960204.,
      969416.,  978628.,  987840.,  1169336., 1180704., 1192072., 1203440.,
      1188348., 1199912., 1211476., 1223040., 1625624., 1641696., 1657768.,
      1673840., 1644636., 1660904., 1677172., 1693440., 1853768., 1872192.,
      1890616., 1909040., 1872780., 1891400., 1910020., 1928640.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      346728.,  432516.,  319260.,  752318.,  897337.,  638295.,  528310.,
      618485.,  428475.,  1539048., 1799364., 1261020., 1974014., 2294425.,
      1595895., 1159030., 1334165., 910875.,  2731368., 3166212., 2202780.,
      3195710., 3691513., 2553495., 1789750., 2049845., 1393275.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      518959.,  557767.,  984655.,  1023463., 1916047., 1954855.,
      2381743., 2420551., 3313135., 3351943., 3778831., 3817639.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      688668.,  693456.,  858858.,  865032.,  633750.,  638520.,  1491994.,
      1504636., 1779239., 1794674., 1265145., 1276590., 1043270., 1056620.,
      1220905., 1236970., 845175.,  856950.,  3052572., 3078096., 3568362.,
      3598728., 2499990., 2522040., 3911194., 3948028., 4545191., 4588850.,
      3160185., 3191790., 2287430., 2318060., 2632105., 2668330., 1795575.,
      1821750., 5416476., 5462736., 6277866., 6332424., 4366230., 4405560.,
      6330394., 6391420., 7311143., 7383026., 5055225., 5106990., 3531590.,
      3579500., 4043305., 4099690., 2745975., 2786550.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1030127., 1037918., 1106959., 1115534., 1952111., 1969310.,
      2028943., 2046926., 3796079., 3832094., 3872911., 3909710.,
      4718063., 4763486., 4794895., 4841102., 6562031., 6626270.,
      6638863., 6703886., 7484015., 7557662., 7560847., 7635278.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1372548.,  1377336.,  1382124.,  1386912.,  1711542.,  1717716.,
      1723890.,  1730064.,  1262730.,  1267500.,  1272270.,  1277040.,
      2971346.,  2983988.,  2996630.,  3009272.,  3543043.,  3558478.,
      3573913.,  3589348.,  2518845.,  2530290.,  2541735.,  2553180.,
      2073190.,  2086540.,  2099890.,  2113240.,  2425745.,  2441810.,
      2457875.,  2473940.,  1678575.,  1690350.,  1702125.,  1713900.,
      6079620.,  6105144.,  6130668.,  6156192.,  7106358.,  7136724.,
      7167090.,  7197456.,  4977930.,  4999980.,  5022030.,  5044080.,
      7785554.,  7822388.,  7859222.,  7896056.,  9046723.,  9090382.,
      9134041.,  9177700.,  6288765.,  6320370.,  6351975.,  6383580.,
      4544230.,  4574860.,  4605490.,  4636120.,  5227985.,  5264210.,
      5300435.,  5336660.,  3564975.,  3591150.,  3617325.,  3643500.,
      10786692., 10832952., 10879212., 10925472., 12501174., 12555732.,
      12610290., 12664848., 8693130.,  8732460.,  8771790.,  8811120.,
      12599762., 12660788., 12721814., 12782840., 14550403., 14622286.,
      14694169., 14766052., 10058685., 10110450., 10162215., 10213980.,
      7015270.,  7063180.,  7111090.,  7159000.,  8030225.,  8086610.,
      8142995.,  8199380.,  5451375.,  5491950.,  5532525.,  5573100.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2052463.,  2060254.,  2068045.,  2075836.,  2205343.,  2213918.,
      2222493.,  2231068.,  3887023.,  3904222.,  3921421.,  3938620.,
      4039903.,  4057886.,  4075869.,  4093852.,  7556143.,  7592158.,
      7628173.,  7664188.,  7709023.,  7745822.,  7782621.,  7819420.,
      9390703.,  9436126.,  9481549.,  9526972.,  9543583.,  9589790.,
      9635997.,  9682204.,  13059823., 13124062., 13188301., 13252540.,
      13212703., 13277726., 13342749., 13407772., 14894383., 14968030.,
      15041677., 15115324., 15047263., 15121694., 15196125., 15270556.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2756040., 3438372., 2538060.,  5984860.,  7138222.,  5076890.,  4195460.,
      4910850., 3400950., 12253128., 14324772., 10037580., 14133084., 13724206.,
      9041690., 2919300., 2363010.,  1425270.,  4866504.,  5857572.,  4204620.,
      8146012., 9609390., 6770330.,  5309060.,  6174210.,  4252150.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4126486.,  4435382., 7833238., 8142134., 15246742., 15555638.,
      11724054., 9599926., 6597654., 6906550., 10304406., 10613302.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5493000.,  5512080.,  6852132.,  6876744.,  5057100.,  5076120.,
      11919236., 11969720., 14214802., 14276444., 10108070., 10153780.,
      5191852.,  5232904.,  5260102.,  5305860.,  2683426.,  2712044.,
      7594248.,  7622544.,  9260580.,  9295944.,  6715980.,  6742680.,
      12496772., 12553912., 12151442., 12213340., 8147110.,  8191540.,
      3184812.,  3217160.,  2819910.,  2852100.,  1824290.,  1847020.,
      9695496.,  9733008.,  11669028., 11715144., 8374860.,  8409240.,
      7864196.,  7911608.,  9498258.,  9556316.,  6759590.,  6802740.,
      2095276.,  2114824.,  2632518.,  2657284.,  1890850.,  1909740.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8221906.,  8252972.,  8836562.,  8870764.,  15597778., 15666476.,
      13877714., 13943404., 10680530., 10724140., 11295186., 11341932.,
      10847442., 10908204., 9037266.,  9092972.,  13139154., 13195308.,
      13753810., 13813100., 7268562.,  7319340.,  7883218.,  7937132.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4352904.,  4371984.,  4391064.,  4410144.,  5629988.,  5654600.,
      5679212.,  5703824.,  4492876.,  4511896.,  4530916.,  4549936.,
      11275732., 11326216., 11376700., 11427184., 13633626., 13695268.,
      13756910., 13818552., 10242750., 10288460., 10334170., 10379880.,
      10130684., 10171736., 10212788., 10253840., 10164174., 10209932.,
      10255690., 10301448., 5210234.,  5238852.,  5267470.,  5296088.,
      6580104.,  6608400.,  6636696.,  6664992.,  8207908.,  8243272.,
      8278636.,  8314000.,  6361164.,  6387864.,  6414564.,  6441264.,
      12555220., 12612360., 12669500., 12726640., 13569882., 13631780.,
      13693678., 13755576., 10123198., 10167628., 10212058., 10256488.,
      5732092.,  5764440.,  5796788.,  5829136.,  4904142.,  4936332.,
      4968522.,  5000712.,  3366778.,  3389508.,  3412238.,  3434968.,
      8807304.,  8844816.,  8882328.,  8919840.,  10785828., 10831944.,
      10878060., 10924176., 8229452.,  8263832.,  8298212.,  8332592.,
      11819476., 11866888., 11914300., 11961712., 14427738., 14485796.,
      14543854., 14601912., 11150526., 11193676., 11236826., 11279976.,
      3172604.,  3192152.,  3211700.,  3231248.,  4143566.,  4168332.,
      4193098.,  4217864.,  3372666.,  3391556.,  3410446.,  3429336.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7109706.,  7140772.,  7171838.,  7202904.,  7778826.,  7813028.,
      7847230.,  7881432.,  15139146., 15207844., 15276542., 15345240.,
      14290698., 14356388., 14422078., 14487768., 9786186.,  9829796.,
      9873406.,  9917016.,  10455306., 10502052., 10548798., 10595544.,
      13903946., 13964708., 14025470., 14086232., 13925898., 13981604.,
      14037310., 14093016., 12462666., 12518820., 12574974., 12631128.,
      13131786., 13191076., 13250366., 13309656., 11867978., 11918756.,
      11969534., 12020312., 12537098., 12591012., 12644926., 12698840.};
  const std::array<int, 4> in_shape = {{3, 12, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      42265.,  61250.,  66038.,  37670.,  92960.,  129654., 134554., 74508.,
      66225.,  90160.,  92680.,  49650.,  190945., 262346., 267134., 146534.,
      245840., 335454., 340354., 185052., 146025., 196000., 198520., 105090.,
      339625., 463442., 468230., 255398., 398720., 541254., 546154., 295596.,
      225825., 301840., 304360., 160530.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {75754.,  80654.,  144354., 149254.,
                                         281554., 286454., 350154., 355054.,
                                         487354., 492254., 555954., 560854.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      83390.,  84530.,  120778.,  122500.,  130186.,  132076.,  74200.,
      75340.,  182875., 185920.,  254898.,  259308.,  264502.,  269108.,
      146314., 149016., 129225.,  132450.,  175700.,  180320.,  180600.,
      185360., 96530.,  99300.,   375710.,  381890.,  515914.,  524692.,
      525322., 534268., 287896.,  293068.,  482755.,  491680.,  658266.,
      670908., 667870., 680708.,  362698.,  370104.,  284625.,  292050.,
      381500., 392000., 386400.,  397040.,  204050.,  210180.,  668030.,
      679250., 911050., 926884.,  920458.,  936460.,  501592.,  510796.,
      782635., 797440., 1061634., 1082508., 1071238., 1092308., 579082.,
      591192., 440025., 451650.,  587300.,  603680.,  592200.,  608720.,
      311570., 321060.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149254., 151508., 158858.,  161308.,  283710.,  288708.,
      293314., 298508., 552622.,  563108.,  562226.,  572908.,
      687078., 700308., 696682.,  710108.,  955990.,  974708.,
      965594., 984508., 1090446., 1111908., 1100050., 1121708.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      165640.,  166780.,  167920.,  169060.,  239834.,  241556.,  243278.,
      245000.,  258482.,  260372.,  262262.,  264152.,  147260.,  148400.,
      149540.,  150680.,  362705.,  365750.,  368795.,  371840.,  505386.,
      509796.,  514206.,  518616.,  524398.,  529004.,  533610.,  538216.,
      289926.,  292628.,  295330.,  298032.,  255225.,  258450.,  261675.,
      264900.,  346780.,  351400.,  356020.,  360640.,  356440.,  361200.,
      365960.,  370720.,  190290.,  193060.,  195830.,  198600.,  745240.,
      751420.,  757600.,  763780.,  1023050., 1031828., 1040606., 1049384.,
      1041698., 1050644., 1059590., 1068536., 570620.,  575792.,  580964.,
      586136.,  956585.,  965510.,  974435.,  983360.,  1303890., 1316532.,
      1329174., 1341816., 1322902., 1335740., 1348578., 1361416., 717990.,
      725396.,  732802.,  740208.,  561825.,  569250.,  576675.,  584100.,
      752500.,  763000.,  773500.,  784000.,  762160.,  772800.,  783440.,
      794080.,  401970.,  408100.,  414230.,  420360.,  1324840., 1336060.,
      1347280., 1358500., 1806266., 1822100., 1837934., 1853768., 1824914.,
      1840916., 1856918., 1872920., 993980.,  1003184., 1012388., 1021592.,
      1550465., 1565270., 1580075., 1594880., 2102394., 2123268., 2144142.,
      2165016., 2121406., 2142476., 2163546., 2184616., 1146054., 1158164.,
      1170274., 1182384., 868425.,  880050.,  891675.,  903300.,  1158220.,
      1174600., 1190980., 1207360., 1167880., 1184400., 1200920., 1217440.,
      613650.,  623140.,  632630.,  642120.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296254.,  298508.,  300762.,  303016.,  315266.,  317716.,  320166.,
      322616.,  562422.,  567420.,  572418.,  577416.,  581434.,  586628.,
      591822.,  597016.,  1094758., 1105244., 1115730., 1126216., 1113770.,
      1124452., 1135134., 1145816., 1360926., 1374156., 1387386., 1400616.,
      1379938., 1393364., 1406790., 1420216., 1893262., 1911980., 1930698.,
      1949416., 1912274., 1931188., 1950102., 1969016., 2159430., 2180892.,
      2202354., 2223816., 2178442., 2200100., 2221758., 2243416.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      334100.,  484204.,  522172.,  297808.,  735805.,  1026011.,
      1064819., 589372.,  522425.,  710815.,  730695.,  391020.,
      1513460., 2078860., 2116828., 1160656., 1947085., 2655947.,
      2694755., 1464316., 1152425., 1545775., 1565655., 827820.,
      2692820., 3673516., 3711484., 2023504., 3158365., 4285883.,
      4324691., 2339260., 1782425., 2380735., 2400615., 1264620.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      599123.,  637931.,  1142435., 1181243., 2229059., 2267867.,
      2772371., 2811179., 3858995., 3897803., 4402307., 4441115.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      663670.,  668200.,  961562.,  968408.,  1036826., 1044344., 591080.,
      595616.,  1459465., 1471610., 2034431., 2052022., 2111263., 2129638.,
      1167964., 1178744., 1031975., 1044850., 1403185., 1421630., 1442385.,
      1461390., 770980.,  782040.,  3002230., 3026920., 4122650., 4157720.,
      4197914., 4233656., 2300648., 2321312., 3858505., 3894170., 5261375.,
      5311894., 5338207., 5389510., 2899036., 2928632., 2275175., 2304850.,
      3049585., 3091550., 3088785., 3131310., 1631140., 1655640., 5340790.,
      5385640., 7283738., 7347032., 7359002., 7422968., 4010216., 4047008.,
      6257545., 6316730., 8488319., 8571766., 8565151., 8649382., 4630108.,
      4678520., 3518375., 3564850., 4695985., 4761470., 4735185., 4801230.,
      2491300., 2529240.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1189279., 1198246., 1266111., 1275862., 2264927., 2284870.,
      2341759., 2362486., 4416223., 4458118., 4493055., 4535734.,
      5491871., 5544742., 5568703., 5622358., 7643167., 7717990.,
      7719999., 7795606., 8718815., 8804614., 8795647., 8882230.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1322810., 1327340., 1331870., 1336400., 1916278., 1923124., 1929970.,
      1936816., 2066134., 2073652., 2081170., 2088688., 1177624., 1182160.,
      1186696., 1191232., 2906785., 2918930., 2931075., 2943220., 4051271.,
      4068862., 4086453., 4104044., 4204151., 4222526., 4240901., 4259276.,
      2325148., 2335928., 2346708., 2357488., 2051075., 2063950., 2076825.,
      2089700., 2787925., 2806370., 2824815., 2843260., 2865765., 2884770.,
      2903775., 2922780., 1530900., 1541960., 1553020., 1564080., 5979770.,
      6004460., 6029150., 6053840., 8210230., 8245300., 8280370., 8315440.,
      8360086., 8395828., 8431570., 8467312., 4580632., 4601296., 4621960.,
      4642624., 2618689., 2637970., 2657251., 2676532., 2831143., 2855038.,
      2878933., 2902828., 2625623., 2648254., 2670885., 2693516., 1393948.,
      1407160., 1420372., 1433584., 757475.,  761550.,  765625.,  769700.,
      1075445., 1081570., 1087695., 1093820., 1153285., 1159970., 1166655.,
      1173340., 636820.,  640840.,  644860.,  648880.,  3540410., 3554540.,
      3568670., 3582800., 4913398., 4933684., 4953970., 4974256., 5063254.,
      5084212., 5105170., 5126128., 2798104., 2810320., 2822536., 2834752.,
      5180385., 5203730., 5227075., 5250420., 7108871., 7142142., 7175413.,
      7208684., 7261751., 7295806., 7329861., 7363916., 3964828., 3984568.,
      4004308., 4024048., 3227075., 3247950., 3268825., 3289700., 4344725.,
      4374370., 4404015., 4433660., 4422565., 4452770., 4482975., 4513180.,
      2343700., 2361160., 2378620., 2396080.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2369591., 2378558., 2387525., 2396492., 2522471., 2532222., 2541973.,
      2551724., 4509911., 4529854., 4549797., 4569740., 4662791., 4683518.,
      4704245., 4724972., 7626263., 7665086., 7703909., 7742732., 6341447.,
      6376958., 6412469., 6447980., 2455223., 2476350., 2497477., 2518604.,
      2087911., 2105726., 2123541., 2141356., 5427191., 5451838., 5476485.,
      5501132., 5580071., 5605502., 5630933., 5656364., 7567511., 7603134.,
      7638757., 7674380., 7720391., 7756798., 7793205., 7829612.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2656780., 3850532., 4152932., 2368304., 4684578., 5546982.,
      5855878., 3242376., 1281726., 1408442., 1566362., 830200.,
      4893580., 6874532., 7176932., 4004144., 3055586., 3557926.,
      3504326., 1938568., 1527550., 2170490., 2328410., 1287160.,
      3597580., 4240932., 3556196., 1990448., 3289250., 4526182.,
      4765446., 2699144., 2719550., 3749690., 3907610., 2112760.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4765446., 5074342., 9089990.,  9398886.,  15398214., 12815334.,
      4985350., 4237478., 10943366., 11252262., 15267910., 15576806.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      5295500.,  5313560.,  7673764.,  7701064.,  8275876.,  8305864.,
      4718512.,  4736608.,  9326790.,  9369156.,  11038034., 11093964.,
      11652690., 11711756., 6449880.,  6484752.,  2538626.,  2563452.,
      2786182.,  2816884.,  3099782.,  3132724.,  1640776.,  1660400.,
      9749900.,  9787160.,  13694884., 13749064., 14296996., 14353864.,
      7974832.,  8008288.,  6073030.,  6111172.,  7067474.,  7115852.,
      6961234.,  7008652.,  3848920.,  3877136.,  3038850.,  3055100.,
      4316550.,  4340980.,  4630150.,  4656820.,  2558280.,  2574320.,
      7159180.,  7195160.,  8435620.,  8481864.,  7071652.,  7112392.,
      3956656.,  3980896.,  6546630.,  6578500.,  9011538.,  9052364.,
      9495122.,  9530892.,  5376728.,  5398288.,  5406850.,  5439100.,
      7452550.,  7499380.,  7766150.,  7815220.,  4196680.,  4225520.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9495122., 9530892., 10109778., 10148684., 9646162.,  9701260.,
      9081170., 9135308., 13306962., 13367948., 11038034., 11093964.,
      7232082., 7279628., 6798162.,  6840652.,  8091218.,  8144652.,
      7067474., 7115852., 10724434., 10766476., 11339090., 11384268.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x12x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4075660.,  4093720.,  4111780.,  4129840.,  6230180.,  6257480.,
      6284780.,  6312080.,  6874660.,  6904648.,  6934636.,  6964624.,
      4495536.,  4513632.,  4531728.,  4549824.,  9295886.,  9338252.,
      9380618.,  9422984.,  12471338., 12527268., 12583198., 12639128.,
      13140458., 13199524., 13258590., 13317656., 8465784.,  8500656.,
      8535528.,  8570400.,  4324362.,  4349188.,  4374014.,  4398840.,
      4715294.,  4745996.,  4776698.,  4807400.,  5241950.,  5274892.,
      5307834.,  5340776.,  3261928.,  3281552.,  3301176.,  3320800.,
      8705420.,  8742680.,  8779940.,  8817200.,  12674980., 12729160.,
      12783340., 12837520., 13319460., 13376328., 13433196., 13490064.,
      8371376.,  8404832.,  8438288.,  8471744.,  9018510.,  9056652.,
      9094794.,  9132936.,  9452970.,  9501348.,  9549726.,  9598104.,
      8684394.,  8731812.,  8779230.,  8826648.,  4843384.,  4871600.,
      4899816.,  4928032.,  4350346.,  4366596.,  4382846.,  4399096.,
      6799262.,  6823692.,  6848122.,  6872552.,  7325918.,  7352588.,
      7379258.,  7405928.,  5100520.,  5116560.,  5132600.,  5148640.,
      9751180.,  9787160.,  9823140.,  9859120.,  14419620., 14465864.,
      14512108., 14558352., 11140132., 11180872., 11221612., 11262352.,
      6111408.,  6135648.,  6159888.,  6184128.,  5712142.,  5744012.,
      5775882.,  5807752.,  7778090.,  7818916.,  7859742.,  7900568.,
      8193258.,  8229028.,  8264798.,  8300568.,  5284216.,  5305776.,
      5327336.,  5348896.,  8087306.,  8119556.,  8151806.,  8184056.,
      12065822., 12112652., 12159482., 12206312., 12592478., 12641548.,
      12690618., 12739688., 8364520.,  8393360.,  8422200.,  8451040.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x12x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8193258.,  8229028.,  8264798.,  8300568.,  8862378.,  8901284.,
      8940190.,  8979096.,  13260138., 13315236., 13370334., 13425432.,
      13671210., 13725348., 13779486., 13833624., 13366890., 13427876.,
      13488862., 13549848., 12471338., 12527268., 12583198., 12639128.,
      8111850.,  8159396.,  8206942.,  8254488.,  6692010.,  6734500.,
      6776990.,  6819480.,  12052458., 12105892., 12159326., 12212760.,
      9452970.,  9501348.,  9549726.,  9598104.,  9531498.,  9573540.,
      9615582.,  9657624.,  10200618., 10245796., 10290974., 10336152.};
  const std::array<int, 4> in_shape = {{3, 12, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      24525.,  36890.,  27925.,  63630.,  90013.,  64610.,  103670., 143913.,
      101570., 42110.,  56602.,  38550.,  151575., 209370., 147275., 203770.,
      278663., 193970., 243810., 332563., 230930., 89850.,  119126., 80130.,
      278625., 381850., 266625., 343910., 467313., 323330., 383950., 521213.,
      360290., 137590., 181650., 121710.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x11x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {60613.,  65513.,  114513., 119413.,
                                         249263., 254163., 303163., 308063.,
                                         437913., 442813., 491813., 496713.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      48425.,  49050.,  72800.,  73780.,  55075.,  55850.,  125230.,  127260.,
      177037., 180026., 126980., 129220., 203770., 207340., 282681.,  287826.,
      199360., 203140., 81630.,  84220.,  109494., 113204., 74390.,   77100.,
      298675., 303150., 412370., 418740., 289925., 294550., 400120.,  407540.,
      546791., 557326., 380310., 387940., 478660., 487620., 652435.,  665126.,
      452690., 461860., 174030., 179700., 230230., 238252., 154470.,  160260.,
      548925., 557250., 751940., 763700., 524775., 533250., 675010.,  687820.,
      916545., 934626., 633640., 646660., 753550., 767900., 1022189., 1042426.,
      706020., 720580., 266430., 275180., 350966., 363300., 234550.,  243420.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x11x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119413., 121226., 129017., 131026., 225057., 229026., 234661., 238826.,
      489167., 498526., 498771., 508326., 594811., 606326., 604415., 616126.,
      858921., 875826., 868525., 885626., 964565., 983626., 974169., 993426.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      96225.,   96850.,   97475.,   98100.,   144620.,  145600.,  146580.,
      147560.,  109375.,  110150.,  110925.,  111700.,  248430.,  250460.,
      252490.,  254520.,  351085.,  354074.,  357063.,  360052.,  251720.,
      253960.,  256200.,  258440.,  403970.,  407540.,  411110.,  414680.,
      560217.,  565362.,  570507.,  575652.,  394940.,  398720.,  402500.,
      406280.,  160670.,  163260.,  165850.,  168440.,  215278.,  218988.,
      222698.,  226408.,  146070.,  148780.,  151490.,  154200.,  592875.,
      597350.,  601825.,  606300.,  818370.,  824740.,  831110.,  837480.,
      575225.,  579850.,  584475.,  589100.,  792820.,  800240.,  807660.,
      815080.,  1083047., 1093582., 1104117., 1114652., 752990.,  760620.,
      768250.,  775880.,  948360.,  957320.,  966280.,  975240.,  1292179.,
      1304870., 1317561., 1330252., 896210.,  905380.,  914550.,  923720.,
      342390.,  348060.,  353730.,  359400.,  452438.,  460460.,  468482.,
      476504.,  303150.,  308940.,  314730.,  320520.,  1089525., 1097850.,
      1106175., 1114500., 1492120., 1503880., 1515640., 1527400., 1041075.,
      1049550., 1058025., 1066500., 1337210., 1350020., 1362830., 1375640.,
      1815009., 1833090., 1851171., 1869252., 1254260., 1267280., 1280300.,
      1293320., 1492750., 1507100., 1521450., 1535800., 2024141., 2044378.,
      2064615., 2084852., 1397480., 1412040., 1426600., 1441160., 524110.,
      532860.,  541610.,  550360.,  689598.,  701932.,  714266.,  726600.,
      460230.,  469100.,  477970.,  486840.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x11x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      237013.,  238826.,  240639.,  242452.,  256025.,  258034.,  260043.,
      262052.,  446145.,  450114.,  454083.,  458052.,  465157.,  469322.,
      473487.,  477652.,  968975.,  978334.,  987693.,  997052.,  987987.,
      997542.,  1007097., 1016652., 1178107., 1189622., 1201137., 1212652.,
      1197119., 1208830., 1220541., 1232252., 1700937., 1717842., 1734747.,
      1751652., 1719949., 1737050., 1754151., 1771252., 1910069., 1929130.,
      1948191., 1967252., 1929081., 1948338., 1967595., 1986852.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      193325.,  290955.,  220325.,  503195.,  711725.,  510755.,
      820435.,  1138613., 803355.,  331100.,  444612.,  302460.,
      1202025., 1660015., 1167425., 1613535., 2205833., 1534855.,
      1930775., 2632721., 1827455., 706860.,  936180.,  628940.,
      2210725., 3029075., 2114525., 2723875., 3699941., 2558955.,
      3041115., 4126829., 2851555., 1082620., 1427748., 955420.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x11x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      478877.,  517685.,  905765.,  944573.,  1972985., 2011793.,
      2399873., 2438681., 3467093., 3505901., 3893981., 3932789.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      384175.,  386650.,  578025.,  581910.,  437575.,  440650.,  998305.,
      1006390., 1411543., 1423450., 1012585., 1021510., 1626625., 1640870.,
      2256695., 2277226., 1591625., 1606710., 651860.,  662200.,  874412.,
      889224.,  594100.,  604920.,  2386175., 2404050., 3294585., 3320030.,
      2316375., 2334850., 3197425., 3227070., 4369575., 4411666., 3039225.,
      3069710., 3825745., 3861550., 5214727., 5265442., 3618265., 3654910.,
      1391060., 1413720., 1840300., 1872360., 1234740., 1257880., 4388175.,
      4421450., 6011145., 6058150., 4195175., 4229050., 5396545., 5447750.,
      7327607., 7399882., 5065865., 5117910., 6024865., 6082230., 8172759.,
      8253658., 5644905., 5703110., 2130260., 2165240., 2806188., 2855496.,
      1875380., 1910840.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x11x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      950551.,  957754.,  1027383., 1035370., 1795703., 1811530.,
      1872535., 1889146., 3908583., 3945970., 3985415., 4023586.,
      4753735., 4799746., 4830567., 4877362., 6866615., 6934186.,
      6943447., 7011802., 7711767., 7787962., 7788599., 7865578.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      765875.,   768350.,   770825.,   773300.,   1152165.,  1156050.,
      1159935.,  1163820.,  872075.,   875150.,   878225.,   881300.,
      1988525.,  1996610.,  2004695.,  2012780.,  2811179.,  2823086.,
      2834993.,  2846900.,  2016245.,  2025170.,  2034095.,  2043020.,
      3239005.,  3253250.,  3267495.,  3281740.,  4492859.,  4513390.,
      4533921.,  4554452.,  3168165.,  3183250.,  3198335.,  3213420.,
      1293380.,  1303720.,  1314060.,  1324400.,  1734012.,  1748824.,
      1763636.,  1778448.,  1177380.,  1188200.,  1199020.,  1209840.,
      4754475.,  4772350.,  4790225.,  4808100.,  6563725.,  6589170.,
      6614615.,  6640060.,  4614275.,  4632750.,  4651225.,  4669700.,
      6365205.,  6394850.,  6424495.,  6454140.,  8697059.,  8739150.,
      8781241.,  8823332.,  6047965.,  6078450.,  6108935.,  6139420.,
      7615685.,  7651490.,  7687295.,  7723100.,  10378739., 10429454.,
      10480169., 10530884., 7199885.,  7236530.,  7273175.,  7309820.,
      2759460.,  2782120.,  2804780.,  2827440.,  3648540.,  3680600.,
      3712660.,  3744720.,  2446340.,  2469480.,  2492620.,  2515760.,
      8743075.,  8776350.,  8809625.,  8842900.,  11975285., 12022290.,
      12069295., 12116300., 8356475.,  8390350.,  8424225.,  8458100.,
      10741885., 10793090., 10844295., 10895500., 14582939., 14655214.,
      14727489., 14799764., 10079685., 10131730., 10183775., 10235820.,
      11992365., 12049730., 12107095., 12164460., 16264619., 16345518.,
      16426417., 16507316., 11231605., 11289810., 11348015., 11406220.,
      4225540.,  4260520.,  4295500.,  4330480.,  5563068.,  5612376.,
      5661684.,  5710992.,  3715300.,  3750760.,  3786220.,  3821680.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x11x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1893899.,  1901102.,  1908305.,  1915508.,  2046779.,  2054766.,
      2062753.,  2070740.,  3575579.,  3591406.,  3607233.,  3623060.,
      3728459.,  3745070.,  3761681.,  3778292.,  7779779.,  7817166.,
      7854553.,  7891940.,  7932659.,  7970830.,  8009001.,  8047172.,
      9461459.,  9507470.,  9553481.,  9599492.,  9614339.,  9661134.,
      9707929.,  9754724.,  13665659., 13733230., 13800801., 13868372.,
      13818539., 13886894., 13955249., 14023604., 15347339., 15423534.,
      15499729., 15575924., 15500219., 15577198., 15654177., 15731156.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1535150., 2311050., 1750350., 4002250., 5660382., 4061610.,
      4618090., 5768126., 3312970., 813240.,  886312.,  415544.,
      2892350., 4152890., 3024350., 5494650., 7668206., 5437530.,
      2706714., 3186382., 2174970., 651000.,  942312.,  682360.,
      4249550., 5994730., 4298350., 3454250., 4844798., 3177226.,
      2354890., 3397086., 2437802., 1154360., 1600424., 1119160.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x11x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3807006.,  4115902., 7204862., 7513758., 15699502., 16008398.,
      11235086., 9743790., 7822654., 8131550., 11220510., 11529406.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3060450.,  3070300.,  4606630.,  4622100.,  3488450.,  3500700.,
      7972230.,  8004500.,  11273234., 11320764., 8087590.,  8123220.,
      9189510.,  9236180.,  11472658., 11536252., 6584102.,  6625940.,
      1605640.,  1626480.,  1746200.,  1772624.,  816520.,   831088.,
      5764450.,  5784700.,  8275750.,  8305780.,  6026050.,  6048700.,
      10942470., 10989300., 15268498., 15336412., 10824870., 10875060.,
      5376774.,  5413428.,  6325650.,  6372764.,  4316070.,  4349940.,
      1293320.,  1302000.,  1871128.,  1884624.,  1354120.,  1364720.,
      8468450.,  8499100.,  11944870., 11989460., 8563650.,  8596700.,
      6867590.,  6908500.,  9629970.,  9689596.,  6312230.,  6354452.,
      4685190.,  4709780.,  6757394.,  6794172.,  4849702.,  4875604.,
      2291720.,  2308720.,  3175704.,  3200848.,  2219400.,  2238320.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x11x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7585298.,  7614012.,  8199954.,  8231804.,  14346514., 14409724.,
      14961170., 15027516., 11580562., 11629660., 12195218., 12247452.,
      10502034., 10563100., 9322642.,  9380700.,  15575826., 15645308.,
      15395858., 15466428., 6280722.,  6327356.,  6559506.,  6607228.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2112330.,  2122180.,  2132030.,  2141880.,  3409118.,  3424588.,
      3440058.,  3455528.,  2836906.,  2849156.,  2861406.,  2873656.,
      7227646.,  7259916.,  7292186.,  7324456.,  10582650., 10630180.,
      10677710., 10725240., 8046878.,  8082508.,  8118138.,  8153768.,
      10204862., 10251532., 10298202., 10344872., 14275002., 14338596.,
      14402190., 14465784., 10505950., 10547788., 10589626., 10631464.,
      3190440.,  3211280.,  3232120.,  3252960.,  3465976.,  3492400.,
      3518824.,  3545248.,  1618472.,  1633040.,  1647608.,  1662176.,
      4741034.,  4761284.,  4781534.,  4801784.,  7111934.,  7141964.,
      7171994.,  7202024.,  5558794.,  5581444.,  5604094.,  5626744.,
      10384670., 10431500., 10478330., 10525160., 14931930., 14999844.,
      15067758., 15135672., 11163966., 11214156., 11264346., 11314536.,
      8209118.,  8245772.,  8282426.,  8319080.,  8765210.,  8812324.,
      8859438.,  8906552.,  5732094.,  5765964.,  5799834.,  5833704.,
      2577960.,  2586640.,  2595320.,  2604000.,  3728760.,  3742256.,
      3755752.,  3769248.,  2697640.,  2708240.,  2718840.,  2729440.,
      7369738.,  7400388.,  7431038.,  7461688.,  10814750., 10859340.,
      10903930., 10948520., 8280682.,  8313732.,  8346782.,  8379832.,
      9957694.,  9998604.,  10039514., 10080424., 14722362., 14781988.,
      14841614., 14901240., 11338078., 11380300., 11422522., 11464744.,
      4069118.,  4093708.,  4118298.,  4142888.,  6018170.,  6054948.,
      6091726.,  6128504.,  4464414.,  4490316.,  4516218.,  4542120.,
      4566440.,  4583440.,  4600440.,  4617440.,  6326264.,  6351408.,
      6376552.,  6401696.,  4419880.,  4438800.,  4457720.,  4476640.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x11x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6567930.,  6596644.,  6625358.,  6654072.,  7237050.,  7268900.,
      7300750.,  7332600.,  13928250., 13991460., 14054670., 14117880.,
      14597370., 14663716., 14730062., 14796408., 10917210., 10966308.,
      11015406., 11064504., 11586330., 11638564., 11690798., 11743032.,
      14154906., 14215972., 14277038., 14338104., 14387802., 14445860.,
      14503918., 14561976., 15266490., 15335972., 15405454., 15474936.,
      15396986., 15467556., 15538126., 15608696., 8397306.,  8443940.,
      8490574.,  8537208.,  8396730.,  8444452.,  8492174.,  8539896.};
  const std::array<int, 4> in_shape = {{3, 14, 11, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      31940.,  40740.,  30600.,  82243.,  98735.,  70630.,  133651., 157535.,
      110950., 53530.,  61922.,  42100.,  195740., 228900., 160800., 262171.,
      304535., 211750., 313579., 363335., 252070., 114010., 130130., 87460.,
      359540., 417060., 291000., 442099., 510335., 352870., 493507., 569135.,
      393190., 174490., 198338., 132820.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x12x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {65660.,  70560.,  124460., 129360.,
                                         271460., 276360., 330260., 335160.,
                                         477260., 482160., 536060., 540960.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      63055.,   63880.,   80395.,  81480.,  60350.,  61200.,  161819.,
      164486.,  194187.,  197470., 138810., 141260., 262619., 267302.,
      309435.,  315070.,  217770., 221900., 103664., 107060., 119784.,
      123844.,  81240.,   84200.,  385615., 391480., 450835., 457800.,
      316550.,  321600.,  514619., 524342., 597555., 609070., 415170.,
      423500.,  615419.,  627158., 712803., 726670., 494130., 504140.,
      220592.,  228020.,  251496., 260260., 168600., 174920., 708175.,
      719080.,  821275.,  834120., 572750., 582000., 867419., 884198.,
      1000923., 1020670., 691530., 705740., 968219., 987014., 1116171.,
      1138270., 770490.,  786380., 337520., 348980., 383208., 396676.,
      255960.,  265640.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x12x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      129360., 131320., 138964.,  141120.,  244608.,  248920.,
      254212., 258720., 532728.,  542920.,  542332.,  552720.,
      647976., 660520., 657580.,  670320.,  936096.,  954520.,
      945700., 964320., 1051344., 1072120., 1060948., 1081920.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      125285.,  126110.,  126935.,  127760.,  159705.,  160790.,  161875.,
      162960.,  119850.,  120700.,  121550.,  122400.,  320971.,  323638.,
      326305.,  328972.,  385091.,  388374.,  391657.,  394940.,  275170.,
      277620.,  280070.,  282520.,  520555.,  525238.,  529921.,  534604.,
      613235.,  618870.,  624505.,  630140.,  431410.,  435540.,  439670.,
      443800.,  203932.,  207328.,  210724.,  214120.,  235508.,  239568.,
      243628.,  247688.,  159520.,  162480.,  165440.,  168400.,  765365.,
      771230.,  777095.,  782960.,  894705.,  901670.,  908635.,  915600.,
      628050.,  633100.,  638150.,  643200.,  1019515., 1029238., 1038961.,
      1048684., 1183595., 1195110., 1206625., 1218140., 822010.,  830340.,
      838670.,  847000.,  1219099., 1230838., 1242577., 1254316., 1411739.,
      1425606., 1439473., 1453340., 978250.,  988260.,  998270.,  1008280.,
      433756.,  441184.,  448612.,  456040.,  494228.,  502992.,  511756.,
      520520.,  330880.,  337200.,  343520.,  349840.,  1405445., 1416350.,
      1427255., 1438160., 1629705., 1642550., 1655395., 1668240., 1136250.,
      1145500., 1154750., 1164000., 1718059., 1734838., 1751617., 1768396.,
      1982099., 2001846., 2021593., 2041340., 1368850., 1383060., 1397270.,
      1411480., 1917643., 1936438., 1955233., 1974028., 2210243., 2232342.,
      2254441., 2276540., 1525090., 1540980., 1556870., 1572760., 663580.,
      675040.,  686500.,  697960.,  752948.,  766416.,  779884.,  793352.,
      502240.,  511920.,  521600.,  531280.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x12x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      256760.,  258720.,  260680.,  262640.,  275772.,  277928.,  280084.,
      282240.,  484904.,  489216.,  493528.,  497840.,  503916.,  508424.,
      512932.,  517440.,  1055264., 1065456., 1075648., 1085840., 1074276.,
      1084664., 1095052., 1105440., 1283408., 1295952., 1308496., 1321040.,
      1302420., 1315160., 1327900., 1340640., 1853768., 1872192., 1890616.,
      1909040., 1872780., 1891400., 1910020., 1928640., 2081912., 2102688.,
      2123464., 2144240., 2100924., 2121896., 2142868., 2163840.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      251950.,  321545.,  241575.,  650510.,  780913.,  558495.,
      1057742., 1246609., 877695.,  420752.,  486472.,  330360.,
      1552270., 1815065., 1274775., 2075822., 2410849., 1675695.,
      2483054., 2876545., 1994895., 896528.,  1022728., 686520.,
      2852590., 3308585., 2307975., 3501134., 4040785., 2792895.,
      3908366., 4506481., 3112095., 1372304., 1558984., 1042680.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x12x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      518959.,  557767.,  984655.,  1023463., 2148895., 2187703.,
      2614591., 2653399., 3778831., 3817639., 4244527., 4283335.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      500630.,  503900.,  638785.,  643090.,  479775.,  483150.,  1290394.,
      1301020., 1548743., 1561826., 1107225., 1116990., 2096794., 2115484.,
      2470727., 2493218., 1738905., 1755390., 827944.,  841504.,  956732.,
      972944.,  648900.,  660720.,  3081110., 3104540., 3602305., 3630130.,
      2529375., 2549550., 4112794., 4151644., 4775687., 4821698., 3318105.,
      3351390., 4919194., 4966108., 5697671., 5753090., 3949785., 3989790.,
      1763368., 1793056., 2010428., 2045456., 1347780., 1373040., 5661590.,
      5705180., 6565825., 6617170., 4578975., 4615950., 6935194., 7002268.,
      8002631., 8081570., 5528985., 5585790., 7741594., 7816732., 8924615.,
      9012962., 6160665., 6224190., 2698792., 2744608., 3064124., 3117968.,
      2046660., 2085360.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x12x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1030127., 1037918., 1106959., 1115534., 1952111., 1969310.,
      2028943., 2046926., 4257071., 4297790., 4333903., 4375406.,
      5179055., 5229182., 5255887., 5306798., 7484015., 7557662.,
      7560847., 7635278., 8405999., 8489054., 8482831., 8566670.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      997990.,  1001260., 1004530., 1007800., 1273265., 1277570., 1281875.,
      1286180., 956175.,  959550.,  962925.,  966300.,  2570162., 2580788.,
      2591414., 2602040., 3084403., 3097486., 3110569., 3123652., 2204685.,
      2214450., 2224215., 2233980., 4174898., 4193588., 4212278., 4230968.,
      4918963., 4941454., 4963945., 4986436., 3461325., 3477810., 3494295.,
      3510780., 1642328., 1655888., 1669448., 1683008., 1897252., 1913464.,
      1929676., 1945888., 1285980., 1297800., 1309620., 1321440., 6138790.,
      6162220., 6185650., 6209080., 7176785., 7204610., 7232435., 7260260.,
      5038575., 5058750., 5078925., 5099100., 5262194., 5292852., 5323510.,
      5354168., 4992595., 5025294., 5057993., 5090692., 3254445., 3277490.,
      3300535., 3323580., 1746930., 1761076., 1775222., 1789368., 1809555.,
      1822990., 1836425., 1849860., 1254765., 1264050., 1273335., 1282620.,
      670808.,  675920.,  681032.,  686144.,  803236.,  809592.,  815948.,
      822304.,  560860.,  565640.,  570420.,  575200.,  3445990., 3458860.,
      3471730., 3484600., 4084465., 4099970., 4115475., 4130980., 2900175.,
      2911550., 2922925., 2934300., 5244722., 5268788., 5292854., 5316920.,
      6142003., 6170766., 6199529., 6228292., 4299085., 4320050., 4341015.,
      4361980., 6849458., 6881588., 6913718., 6945848., 7976563., 8014734.,
      8052905., 8091076., 5555725., 5583410., 5611095., 5638780., 2525528.,
      2546768., 2568008., 2589248., 2891812., 2916984., 2942156., 2967328.,
      1945180., 1963400., 1981620., 1999840.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x12x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2052463., 2060254., 2068045., 2075836., 2205343., 2213918., 2222493.,
      2231068., 3887023., 3904222., 3921421., 3938620., 4039903., 4057886.,
      4075869., 4093852., 8473423., 8514142., 8554861., 8595580., 8626303.,
      8667806., 8709309., 8750812., 3058063., 3083614., 3109165., 3134716.,
      2461375., 2483614., 2505853., 2528092., 5110063., 5133534., 5157005.,
      5180476., 5262943., 5287198., 5311453., 5335708., 6944623., 6977502.,
      7010381., 7043260., 7097503., 7131166., 7164829., 7198492.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2001380.,  2554930.,  1919750.,  5174428.,  6211534.,  4441850.,
      8416156.,  9918286.,  6982010.,  3336112.,  3856216.,  2617160.,
      12363620., 14456050., 10151750., 10638620., 10106382., 6594490.,
      3542044.,  3663246.,  2540090.,  1359280.,  1628760.,  1138760.,
      6935780.,  8222130.,  5839750.,  10577308., 12389454., 8675450.,
      13819036., 16096206., 11215610., 5133232.,  5881176.,  3961160.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x12x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4126486., 4435382., 7833238., 6971702., 7215446., 7524342.,
      3623126., 3174262., 3659670., 3968566., 4126486., 4435382.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3989740.,  4002760.,  5092710.,  5109860.,  3826050., 3839500.,
      10306436., 10348856., 12370834., 12423068., 8844710., 8883700.,
      8401796.,  8451896.,  8998802.,  9055900.,  5149094., 5186292.,
      1309616.,  1326944.,  1429912.,  1447600.,  935432.,  943760.,
      8904940.,  8937160.,  10737510., 10777060., 7730050., 7759500.,
      9816964.,  9869880.,  9465234.,  9522204.,  6338470., 6379380.,
      5979012.,  6015032.,  6748562.,  6785820.,  4838310., 4865140.,
      2698160.,  2718560.,  3232152.,  3257520.,  2258440., 2277520.,
      9298156.,  9337288.,  11164006., 11211620., 7988610., 8023820.,
      5329796.,  5364536.,  6600594.,  6643868.,  4774310., 4806900.,
      10306436., 10348856., 12370834., 12423068., 8844710., 8883700.,
      4479920.,  4515680.,  5239192.,  5282480.,  3589640., 3621520.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x12x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8221906.,  8252972.,  8836562.,  8870764.,  15597778., 15666476.,
      13877714., 13943404., 14368466., 14430892., 14983122., 15048684.,
      7195346.,  7246252.,  6302674.,  6348524.,  7268562.,  7319340.,
      7883218.,  7937132.,  8221906.,  8252972.,  8836562.,  8870764.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2827004.,  2840024.,  2853044.,  2866064.,  3789774.,  3806924.,
      3824074.,  3841224.,  3117690.,  3131140.,  3144590.,  3158040.,
      9532756.,  9575176.,  9617596.,  9660016.,  11626266., 11678500.,
      11730734., 11782968., 8804094.,  8843084.,  8882074.,  8921064.,
      12400468., 12450568., 12500668., 12550768., 14969882., 15026980.,
      15084078., 15141176., 8623614.,  8660812.,  8698010.,  8735208.,
      2601904.,  2619232.,  2636560.,  2653888.,  2842136.,  2859824.,
      2877512.,  2895200.,  1862536.,  1870864.,  1879192.,  1887520.,
      7723004.,  7755224.,  7787444.,  7819664.,  9486414.,  9525964.,
      9565514.,  9605064.,  7305210.,  7334660.,  7364110.,  7393560.,
      12016724., 12069640., 12122556., 12175472., 13871258., 13928228.,
      13985198., 14042168., 10670974., 10711884., 10752794., 10793704.,
      5799508.,  5835528.,  5871548.,  5907568.,  5967258.,  6004516.,
      6041774.,  6079032.,  4407934.,  4434764.,  4461594.,  4488424.,
      5375920.,  5396320.,  5416720.,  5437120.,  6438936.,  6464304.,
      6489672.,  6515040.,  4497800.,  4516880.,  4535960.,  4555040.,
      9878780.,  9917912.,  9957044.,  9996176.,  12100814., 12148428.,
      12196042., 12243656., 9454970.,  9490180.,  9525390.,  9560600.,
      5485396.,  5520136.,  5554876.,  5589616.,  6779418.,  6822692.,
      6865966.,  6909240.,  4995070.,  5027660.,  5060250.,  5092840.,
      9532756.,  9575176.,  9617596.,  9660016.,  11626266., 11678500.,
      11730734., 11782968., 8804094.,  8843084.,  8882074.,  8921064.,
      8924080.,  8959840.,  8995600.,  9031360.,  10435096., 10478384.,
      10521672., 10564960., 7147400.,  7179280.,  7211160.,  7243040.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x12x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7109706.,  7140772.,  7171838.,  7202904.,  7778826.,  7813028.,
      7847230.,  7881432.,  15139146., 15207844., 15276542., 15345240.,
      14290698., 14356388., 14422078., 14487768., 13800906., 13863332.,
      13925758., 13988184., 14470026., 14535588., 14601150., 14666712.,
      10607306., 10658212., 10709118., 10760024., 8269962.,  8315812.,
      8361662.,  8407512.,  11867978., 11918756., 11969534., 12020312.,
      12537098., 12591012., 12644926., 12698840., 7109706.,  7140772.,
      7171838.,  7202904.,  7778826.,  7813028.,  7847230.,  7881432.};
  const std::array<int, 4> in_shape = {{3, 14, 12, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      30525.,  45080.,  49560.,  28650.,  80220.,  112504., 117404., 65296.,
      131180., 181104., 186004., 102144., 53330.,  71344.,  72968.,  38068.,
      192225., 264600., 269080., 148210., 258580., 352604., 357504., 194264.,
      309540., 421204., 426104., 231112., 114090., 150920., 152544., 78836.,
      353925., 484120., 488600., 267770., 436940., 592704., 597604., 323232.,
      487900., 661304., 666204., 360080., 174850., 230496., 232120., 119604.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x14x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {75754.,  80654.,  144354., 149254.,
                                         315854., 320754., 384454., 389354.,
                                         555954., 560854., 624554., 629454.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      60275.,   61050.,   88970.,  90160.,  97790.,   99120.,   56490.,
      57300.,   157885.,  160440., 221284., 225008.,  230888.,  234808.,
      128282.,  130592.,  257845., 262360., 355740.,  362208.,  365344.,
      372008.,  200410.,  204288., 103380., 106660.,  138012.,  142688.,
      141148.,  145936.,  73360.,  76136.,  378775.,  384450.,  521150.,
      529200.,  529970.,  538160., 291690., 296420.,  507745.,  517160.,
      691880.,  705208.,  701484., 715008., 380730.,  388528.,  607705.,
      619080.,  826336.,  842408., 835940., 852208.,  452858.,  462224.,
      220980.,  228180.,  291676., 301840., 294812.,  305088.,  151760.,
      157672.,  697275.,  707850., 953330., 968240.,  962150.,  977200.,
      526890.,  535540.,  857605., 873880., 1162476., 1185408., 1172080.,
      1195208., 633178.,  646464., 957565., 975800.,  1296932., 1322608.,
      1306536., 1332408., 705306., 720160., 338580.,  349700.,  445340.,
      460992.,  448476.,  464240., 230160., 239208.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x14x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      149254.,  151508.,  158858.,  161308.,  283710.,  288708.,
      293314.,  298508.,  619850.,  631708.,  629454.,  641508.,
      754306.,  768908.,  763910.,  778708.,  1090446., 1111908.,
      1100050., 1121708., 1224902., 1249108., 1234506., 1258908.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      119775.,  120550.,  121325.,  122100.,  176750.,  177940.,  179130.,
      180320.,  194250.,  195580.,  196910.,  198240.,  112170.,  112980.,
      113790.,  114600.,  313215.,  315770.,  318325.,  320880.,  438844.,
      442568.,  446292.,  450016.,  457856.,  461776.,  465696.,  469616.,
      254254.,  256564.,  258874.,  261184.,  511175.,  515690.,  520205.,
      524720.,  705012.,  711480.,  717948.,  724416.,  724024.,  730688.,
      737352.,  744016.,  396942.,  400820.,  404698.,  408576.,  203480.,
      206760.,  210040.,  213320.,  271348.,  276024.,  280700.,  285376.,
      277508.,  282296.,  287084.,  291872.,  143944.,  146720.,  149496.,
      152272.,  751875.,  757550.,  763225.,  768900.,  1034250., 1042300.,
      1050350., 1058400., 1051750., 1059940., 1068130., 1076320., 578650.,
      583380.,  588110.,  592840.,  1006075., 1015490., 1024905., 1034320.,
      1370432., 1383760., 1397088., 1410416., 1389444., 1402968., 1416492.,
      1430016., 753662.,  761460.,  769258.,  777056.,  1204035., 1215410.,
      1226785., 1238160., 1636600., 1652672., 1668744., 1684816., 1655612.,
      1671880., 1688148., 1704416., 896350.,  905716.,  915082.,  924448.,
      434760.,  441960.,  449160.,  456360.,  573188.,  583352.,  593516.,
      603680.,  579348.,  589624.,  599900.,  610176.,  297608.,  303520.,
      309432.,  315344.,  1383975., 1394550., 1405125., 1415700., 1891750.,
      1906660., 1921570., 1936480., 1909250., 1924300., 1939350., 1954400.,
      1045130., 1053780., 1062430., 1071080., 1698935., 1715210., 1731485.,
      1747760., 2302020., 2324952., 2347884., 2370816., 2321032., 2344160.,
      2367288., 2390416., 1253070., 1266356., 1279642., 1292928., 1896895.,
      1915130., 1933365., 1951600., 2568188., 2593864., 2619540., 2645216.,
      2587200., 2613072., 2638944., 2664816., 1395758., 1410612., 1425466.,
      1440320., 666040.,  677160.,  688280.,  699400.,  875028.,  890680.,
      906332.,  921984.,  881188.,  896952.,  912716.,  928480.,  451272.,
      460320.,  469368.,  478416.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x14x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      296254.,  298508.,  300762.,  303016.,  315266.,  317716.,  320166.,
      322616.,  562422.,  567420.,  572418.,  577416.,  581434.,  586628.,
      591822.,  597016.,  1227842., 1239700., 1251558., 1263416., 1246854.,
      1258908., 1270962., 1283016., 1494010., 1508612., 1523214., 1537816.,
      1513022., 1527820., 1542618., 1557416., 2159430., 2180892., 2202354.,
      2223816., 2178442., 2200100., 2221758., 2243416., 2425598., 2449804.,
      2474010., 2498216., 2444610., 2469012., 2493414., 2517816.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      241025.,  356055.,  391615.,  226380.,  634865.,  890183.,  928991.,
      516460.,  1038625., 1433495., 1472303., 808108.,  419480.,  560616.,
      573384.,  298592.,  1524825., 2098495., 2134055., 1175020., 2048025.,
      2791775., 2830583., 1537228., 2451785., 3335087., 3373895., 1828876.,
      897720.,  1186248., 1199016., 618464.,  2808625., 3840935., 3876495.,
      2123660., 3461185., 4693367., 4732175., 2557996., 3864945., 5236679.,
      5275487., 2849644., 1375960., 1811880., 1824648., 938336.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x14x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      599123.,  637931.,  1142435., 1181243., 2500715., 2539523.,
      3044027., 3082835., 4402307., 4441115., 4945619., 4984427.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      478975.,   482050.,   707385.,  712110.,  777945.,  783230.,   449540.,
      452760.,   1259545.,  1269730., 1765519., 1780366., 1842351.,  1857982.,
      1023708.,  1032920.,  2059225., 2077250., 2841167., 2866990.,  2917999.,
      2944606.,  1600732.,  1616216., 825860.,  838960.,  1102556.,  1121232.,
      1127644.,  1146768.,  586096.,  597184.,  3026975., 3049650.,  4164825.,
      4196990.,  4235385.,  4268110., 2331140., 2350040., 4058425.,  4096050.,
      5530287.,  5583550.,  5607119., 5661166., 3043292., 3074456.,  4858105.,
      4903570.,  6605935.,  6670174., 6682767., 6747790., 3620316.,  3657752.,
      1766660.,  1795440.,  2331868., 2372496., 2356956., 2398032.,  1213296.,
      1236928.,  5574975.,  5617250., 7622265., 7681870., 7692825.,  7752990.,
      4212740.,  4247320.,  6857305., 6922370., 9295055., 9386734.,  9371887.,
      9464350.,  5062876.,  5115992., 7656985., 7729890., 10370703., 10473358.,
      10447535., 10550974., 5639900., 5699288., 2707460., 2751920.,  3561180.,
      3623760.,  3586268.,  3649296., 1840496., 1876672.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x14x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1189279., 1198246., 1266111., 1275862., 2264927., 2284870.,
      2341759., 2362486., 4954047., 5001430., 5030879., 5079046.,
      6029695., 6088054., 6106527., 6165670., 8718815., 8804614.,
      8795647., 8882230., 9794463., 9891238., 9871295., 9968854.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      954875.,  957950.,  961025.,  964100.,  1410045., 1414770., 1419495.,
      1424220., 1550605., 1555890., 1561175., 1566460., 895860.,  899080.,
      902300.,  905520.,  2508905., 2519090., 2529275., 2539460., 3516191.,
      3531038., 3545885., 3560732., 3669071., 3684702., 3700333., 3715964.,
      2038204., 2047416., 2056628., 2065840., 4100425., 4118450., 4136475.,
      4154500., 5656511., 5682334., 5708157., 5733980., 5809391., 5835998.,
      5862605., 5889212., 3185980., 3201464., 3216948., 3232432., 1638620.,
      1651720., 1664820., 1677920., 2186436., 2205112., 2223788., 2242464.,
      2236164., 2255288., 2274412., 2293536., 1161104., 1172192., 1183280.,
      1194368., 5634987., 5656638., 5678289., 5699940., 6397965., 6425010.,
      6452055., 6479100., 5836061., 5861618., 5887175., 5912732., 3205684.,
      3220488., 3235292., 3250096., 2034553., 2050674., 2066795., 2082916.,
      2255183., 2274654., 2294125., 2313596., 2164351., 2182558., 2200765.,
      2218972., 1160700., 1171384., 1182068., 1192752., 2395225., 2404850.,
      2414475., 2424100., 3363311., 3377374., 3391437., 3405500., 3516191.,
      3531038., 3545885., 3560732., 1956220., 1964984., 1973748., 1982512.,
      1067420., 1075720., 1084020., 1092320., 1440516., 1452472., 1464428.,
      1476384., 1490244., 1502648., 1515052., 1527456., 780944.,  788192.,
      795440.,  802688.,  4477275., 4493950., 4510625., 4527300., 6189085.,
      6212850., 6236615., 6260380., 6329645., 6353970., 6378295., 6402620.,
      3496180., 3510280., 3524380., 3538480., 6374025., 6403250., 6432475.,
      6461700., 8317823., 8358302., 8398781., 8439260., 6967471., 7004638.,
      7041805., 7078972., 3387964., 3408312., 3428660., 3449008., 2087785.,
      2104370., 2120955., 2137540., 2688031., 2710814., 2733597., 2756380.,
      2255183., 2274654., 2294125., 2313596., 1078716., 1088952., 1099188.,
      1109424., 496220.,  499720.,  503220.,  506720.,  694596.,  699832.,
      705068.,  710304.,  744324.,  750008.,  755692.,  761376.,  400784.,
      404192.,  407600.,  411008.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x14x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2369591., 2378558., 2387525., 2396492., 2522471., 2532222., 2541973.,
      2551724., 4509911., 4529854., 4549797., 4569740., 4662791., 4683518.,
      4704245., 4724972., 4237927., 4267902., 4297877., 4327852., 3411863.,
      3438526., 3465189., 3491852., 2278151., 2290430., 2302709., 2314988.,
      2369591., 2378558., 2387525., 2396492., 7567511., 7603134., 7638757.,
      7674380., 7720391., 7756798., 7793205., 7829612., 4905271., 4937534.,
      4969797., 5002060., 4237927., 4267902., 4297877., 4327852.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1915550., 2830170., 3113530., 1799800., 5051410., 7082166., 7391062.,
      4108104., 2742354., 3349878., 3658774., 2021448., 849160.,  1204504.,
      1305752., 710176.,  5066814., 5737530., 5314330., 2975992., 2866930.,
      3513686., 3574774., 1990344., 4821810., 6773270., 7082166., 3942344.,
      2165640., 2271384., 1614872., 831520.,  2333150., 3396890., 3680250.,
      2108280., 5510610., 7301622., 6099094., 2993736., 2806290., 3798710.,
      3513686., 1824584., 1004040., 1407000., 1508248., 813600.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x14x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      4765446., 5074342., 9089990.,  9398886.,  8586150., 6920774.,
      4595814., 4765446., 15267910., 15576806., 9929990., 8586150.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 1024.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3818850.,  3831100.,  5641510.,  5660340.,  6205990.,  6227060.,
      3586760.,  3599600.,  10062150., 10102820., 14105042., 14164332.,
      14719698., 14782124., 8179416.,  8216208.,  5449542.,  5484708.,
      6653906.,  6699756.,  7268562.,  7317548.,  4013784.,  4042896.,
      1686920.,  1698320.,  2391704.,  2409008.,  2592408.,  2611504.,
      1408800.,  1420352.,  10096226., 10133628., 11428390., 11475060.,
      10583846., 10628660., 5925576.,  5951984.,  5698118.,  5733860.,
      6982354.,  7027372.,  7105490.,  7149548.,  3954392.,  3980688.,
      9605190.,  9643620.,  13490386., 13546540., 14105042., 14164332.,
      7849688.,  7884688.,  4298120.,  4331280.,  4501144.,  4542768.,
      3194520.,  3229744.,  1642272.,  1663040.,  4650850.,  4666300.,
      6770470.,  6793780.,  7334950.,  7360500.,  4201160.,  4216560.,
      10976070., 11021220., 14539730., 14603244., 12139730., 12198188.,
      5955288.,  5987472.,  5577030.,  5612580.,  7547346.,  7597420.,
      6982354.,  7027372.,  3624664.,  3649168.,  1994120.,  2008080.,
      2793112.,  2814000.,  2993816.,  3016496.,  1613600.,  1627200.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x14x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      9495122.,  9530892.,  10109778., 10148684., 9646162.,  9701260.,
      9081170.,  9135308.,  8663890.,  8718156.,  7312466.,  7361676.,
      9011538.,  9052364.,  9495122.,  9530892.,  10724434., 10766476.,
      11339090., 11384268., 9695826.,  9753100.,  8663890.,  8718156.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, SAME3x14x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2619114.,  2631364.,  2643614.,  2655864.,  4123838.,  4142668.,
      4161498.,  4180328.,  4693502.,  4714572.,  4735642.,  4756712.,
      3154792.,  3167632.,  3180472.,  3193312.,  9113518.,  9154188.,
      9194858.,  9235528.,  13211658., 13270948., 13330238., 13389528.,
      13880778., 13943204., 14005630., 14068056., 8646136.,  8682928.,
      8719720.,  8756512.,  7561518.,  7596684.,  7631850.,  7667016.,
      8349834.,  8395684.,  8441534.,  8487384.,  9018954.,  9067940.,
      9116926.,  9165912.,  5041144.,  5070256.,  5099368.,  5128480.,
      3362440.,  3373840.,  3385240.,  3396640.,  4766104.,  4783408.,
      4800712.,  4818016.,  5165720.,  5184816.,  5203912.,  5223008.,
      2806048.,  2817600.,  2829152.,  2840704.,  8955562.,  8992964.,
      9030366.,  9067768.,  11442686., 11489356., 11536026., 11582696.,
      11295550., 11340364., 11385178., 11429992., 7556712.,  7583120.,
      7609528.,  7635936.,  6780142.,  6815884.,  6851626.,  6887368.,
      7336394.,  7381412.,  7426430.,  7471448.,  7026570.,  7070628.,
      7114686.,  7158744.,  4138744.,  4165040.,  4191336.,  4217632.,
      8627822.,  8666252.,  8704682.,  8743112.,  12542538., 12598692.,
      12654846., 12711000., 13211658., 13270948., 13330238., 13389528.,
      8250616.,  8285616.,  8320616.,  8355616.,  8563080.,  8596240.,
      8629400.,  8662560.,  8960664.,  9002288.,  9043912.,  9085536.,
      6353816.,  6389040.,  6424264.,  6459488.,  3263776.,  3284544.,
      3305312.,  3326080.,  3427946.,  3443396.,  3458846.,  3474296.,
      5263166.,  5286476.,  5309786.,  5333096.,  5832830.,  5858380.,
      5883930.,  5909480.,  3856744.,  3872144.,  3887544.,  3902944.,
      10084910., 10130060., 10175210., 10220360., 14011274., 14074788.,
      14138302., 14201816., 12853578., 12912036., 12970494., 13028952.,
      7872504.,  7904688.,  7936872.,  7969056.,  6964142.,  6999692.,
      7035242.,  7070792.,  9018378.,  9068452.,  9118526.,  9168600.,
      7336394.,  7381412.,  7426430.,  7471448.,  3743224.,  3767728.,
      3792232.,  3816736.,  3974280.,  3988240.,  4002200.,  4016160.,
      5565336.,  5586224.,  5607112.,  5628000.,  5964952.,  5987632.,
      6010312.,  6032992.,  3213600.,  3227200.,  3240800.,  3254400.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}
TYPED_TEST(ForwardWindow7Stride4, VALID3x14x14x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8193258.,  8229028.,  8264798.,  8300568.,  8862378.,  8901284.,
      8940190.,  8979096.,  13260138., 13315236., 13370334., 13425432.,
      13671210., 13725348., 13779486., 13833624., 14868138., 14922404.,
      14976670., 15030936., 11613290., 11662500., 11711710., 11760920.,
      7778090.,  7818916.,  7859742.,  7900568.,  8193258.,  8229028.,
      8264798.,  8300568.,  9531498.,  9573540.,  9615582.,  9657624.,
      10200618., 10245796., 10290974., 10336152., 14340330., 14397604.,
      14454878., 14512152., 14868138., 14922404., 14976670., 15030936.};
  const std::array<int, 4> in_shape = {{3, 14, 14, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 512.0;
  this->run_forward_test(exp_out, in_shape, features, padding, max_input_val);
}